Datasets:

---

Anonymous2023

/

KGSum

like 0

[ "customize", "request", "specification" ]

[ "public", "fake", "outer", "string", "serialize", "oper", "req", "spec", "(", "consumer", "<", "request", "spec", "builder", ">", "req", "spec", "customizer", ")", "{", "req", "spec", "customizer", "accept", "(", "req", "spec", ")", ";", "return", "this", ";", "}" ]

[ "validate", "that", "queued", "packets", "contains", "proposal", "in", "the", "following", "orders", "as", "a", "given", "array", "of", "zxids" ]

[ "public", "void", "queued", "packet", "matches", "(", "long", "[", "]", "zxids", ")", "{", "int", "index", "=", "0", ";", "for", "(", "quorum", "packet", "qp", ":", "learner", "handler", "get", "queued", "packets", "(", ")", ")", "{", "if", "(", "qp", "get", "type", "(", ")", "=", "=", "leader", "proposal", ")", "{", "assert", "zxid", "equals", "(", "zxids", "[", "index", "+", "+", "]", ",", "qp", "get", "zxid", "(", ")", ")", ";", "}", "}", "}" ]

[ "returns", "a", "description", "of", "the", "constraint", "suitable", "for", "displaying", "in", "a", "tooltip" ]

[ "public", "default", "string", "get", "constraint", "value", "tooltip", "(", ")", "{", "return", "get", "constraint", "value", "string", "(", ")", ";", "}" ]

[ "called", "when", "the", "game", "loop", "has", "stopped" ]

[ "protected", "void", "stopped", "(", ")", "{", "}" ]

[ "returns", "a", "new", "{", "@", "link", "org", "activiti", "engine", "query", "native", "query", "}", "for", "process", "definitions" ]

[ "native", "model", "query", "create", "native", "model", "query", "(", ")", ";" ]

[ "returns", "a", "fluent", "iterable", "whose", "{", "@", "code", "iterator", "}", "cycles", "indefinitely", "over", "the", "elements", "of", "this", "fluent", "iterable", "that", "iterator", "supports", "{", "@", "code", "remove", "(", ")", "}", "if", "{", "@", "code", "iterable", "iterator", "(", ")", "}", "does", "after", "{", "@", "code", "remove", "(", ")", "}", "is", "called", ",", "subsequent", "cycles", "omit", "the", "removed", "element", ",", "which", "is", "no", "longer", "in", "this", "fluent", "iterable", "the", "iterator", "'", "s", "{", "@", "code", "has", "next", "(", ")", "}", "method", "returns", "{", "@", "code", "true", "}", "until", "this", "fluent", "iterable", "is", "empty", "<", "b", ">", "warning", ":", "<", "b", ">", "typical", "uses", "of", "the", "resulting", "iterator", "may", "produce", "an", "infinite", "loop", "you", "should", "use", "an", "explicit", "{", "@", "code", "break", "}", "or", "be", "certain", "that", "you", "will", "eventually", "remove", "all", "the", "elements", "<", "b", ">", "{", "@", "code", "stream", "}", "equivalent", ":", "<", "b", ">", "if", "the", "source", "iterable", "has", "only", "a", "single", "element", "{", "@", "code", "e", "}", ",", "use", "{", "@", "code", "stream", "generate", "(", "(", ")", "-", ">", "e", ")", "}", "otherwise", ",", "collect", "your", "stream", "into", "a", "collection", "and", "use", "{", "@", "code", "stream", "generate", "(", "(", ")", "-", ">", "collection", ")", "flat", "map", "(", "collection", ":", ":", "stream", ")", "}" ]

[ "public", "final", "fluent", "iterable", "<", "e", ">", "cycle", "(", ")", "{", "return", "from", "(", "iterables", "cycle", "(", "get", "delegate", "(", ")", ")", ")", ";", "}" ]

[ "return", "the", "size", "of", "the", "record", "batch", "header", "for", "v0", "and", "v1", "with", "no", "compression", ",", "it", "'", "s", "unclear", "if", "records", "log", "overhead", "or", "0", "should", "be", "chosen", "there", "is", "no", "header", "per", "batch", ",", "but", "a", "sequence", "of", "batches", "is", "preceded", "by", "the", "offset", "and", "size", "this", "method", "returns", "`", "0", "`", "as", "it", "'", "s", "what", "`", "memory", "records", "builder", "`", "requires" ]

[ "public", "static", "int", "record", "batch", "header", "size", "in", "bytes", "(", "byte", "magic", ",", "compression", "type", "compression", "type", ")", "{", "if", "(", "magic", ">", "record", "batch", "magic", "value", "v1", ")", "{", "return", "default", "record", "batch", "record", "batch", "overhead", ";", "}", "else", "if", "(", "compression", "type", "!", "=", "compression", "type", "none", ")", "{", "return", "records", "log", "overhead", "+", "legacy", "record", "record", "overhead", "(", "magic", ")", ";", "}", "else", "{", "return", "0", ";", "}", "}" ]

[ "this", "test", "makes", "sure", "the", "client", "gets", "the", "key", "provider", "uri", "from", "namenode", "instead", "of", "its", "own", "conf", "this", "test", "assumes", "both", "the", "namenode", "and", "client", "are", "upgraded" ]

[ "public", "void", "test", "different", "k", "m", "s", "provider", "on", "upgraded", "namenode", "(", ")", "throws", "exception", "{", "configuration", "cluster", "conf", "=", "cluster", "get", "configuration", "(", "0", ")", ";", "uri", "namenode", "key", "provider", "uri", "=", "uri", "create", "(", "get", "key", "provider", "u", "r", "i", "(", ")", ")", ";", "assert", "assert", "equals", "(", "\"", "key", "provider", "for", "client", "and", "namenode", "are", "different", "\"", ",", "namenode", "key", "provider", "uri", ",", "cluster", "get", "file", "system", "(", ")", "get", "client", "(", ")", "get", "key", "provider", "uri", "(", ")", ")", ";", "/", "/", "unset", "the", "provider", "path", "in", "conf", "cluster", "conf", "unset", "(", "common", "configuration", "keys", "public", "hadoop", "security", "key", "provider", "path", ")", ";", "/", "/", "even", "after", "unsetting", "the", "local", "conf", ",", "the", "client", "key", "provider", "should", "be", "/", "/", "the", "same", "as", "namenode", "'", "s", "provider", "assert", "assert", "equals", "(", "\"", "key", "provider", "for", "client", "and", "namenode", "are", "different", "\"", ",", "namenode", "key", "provider", "uri", ",", "cluster", "get", "file", "system", "(", ")", "get", "client", "(", ")", "get", "key", "provider", "uri", "(", ")", ")", ";", "/", "/", "set", "the", "provider", "path", "to", "some", "dummy", "scheme", "cluster", "conf", "set", "(", "common", "configuration", "keys", "public", "hadoop", "security", "key", "provider", "path", ",", "\"", "dummy", ":", "/", "/", "foo", ":", "bar", "@", "test", "provider", "1", "\"", ")", ";", "/", "/", "even", "after", "pointing", "the", "conf", "to", "some", "dummy", "provider", ",", "the", "client", "key", "/", "/", "provider", "should", "be", "the", "same", "as", "namenode", "'", "s", "provider", "assert", "assert", "equals", "(", "\"", "key", "provider", "for", "client", "and", "namenode", "are", "different", "\"", ",", "namenode", "key", "provider", "uri", ",", "cluster", "get", "file", "system", "(", ")", "get", "client", "(", ")", "get", "key", "provider", "uri", "(", ")", ")", ";", "/", "/", "ignore", "the", "key", "provider", "from", "nn", "cluster", "conf", "set", "boolean", "(", "dfs", "client", "ignore", "namenode", "default", "kms", "uri", ",", "true", ")", ";", "assert", "assert", "equals", "(", "\"", "expecting", "key", "provider", "for", "client", "config", "\"", ",", "\"", "dummy", ":", "/", "/", "foo", ":", "bar", "@", "test", "provider", "1", "\"", ",", "cluster", "get", "file", "system", "(", ")", "get", "client", "(", ")", "get", "key", "provider", "uri", "(", ")", "to", "string", "(", ")", ")", ";", "assert", "assert", "not", "equals", "(", "\"", "key", "provider", "for", "client", "and", "namenode", "is", "different", "\"", ",", "namenode", "key", "provider", "uri", ",", "cluster", "get", "file", "system", "(", ")", "get", "client", "(", ")", "get", "key", "provider", "uri", "(", ")", "to", "string", "(", ")", ")", ";", "}" ]

[ "ensures", "that", "this", "type", "token", "doesn", "'", "t", "contain", "type", "variables", ",", "which", "can", "cause", "unchecked", "type", "errors", "for", "callers", "like", "{", "@", "link", "type", "to", "instance", "map", "}" ]

[ "final", "type", "token", "<", "t", ">", "reject", "type", "variables", "(", ")", "{", "new", "type", "visitor", "(", ")", "{", "@", "override", "void", "visit", "type", "variable", "(", "type", "variable", "<", "?", ">", "type", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "runtime", "type", "+", "\"", "contains", "a", "type", "variable", "and", "is", "not", "safe", "for", "the", "operation", "\"", ")", ";", "}", "@", "override", "void", "visit", "wildcard", "type", "(", "wildcard", "type", "type", ")", "{", "visit", "(", "type", "get", "lower", "bounds", "(", ")", ")", ";", "visit", "(", "type", "get", "upper", "bounds", "(", ")", ")", ";", "}", "@", "override", "void", "visit", "parameterized", "type", "(", "parameterized", "type", "type", ")", "{", "visit", "(", "type", "get", "actual", "type", "arguments", "(", ")", ")", ";", "visit", "(", "type", "get", "owner", "type", "(", ")", ")", ";", "}", "@", "override", "void", "visit", "generic", "array", "type", "(", "generic", "array", "type", "type", ")", "{", "visit", "(", "type", "get", "generic", "component", "type", "(", ")", ")", ";", "}", "}", "visit", "(", "runtime", "type", ")", ";", "return", "this", ";", "}" ]

[ "todo", "link", "to", "the", "wiki" ]

[ "public", "void", "on", "visibility", "state", "changed", "(", "@", "visibility", "int", "visibility", "state", ",", "@", "non", "null", "t", "view", ")", "{", "}" ]

[ "add", "a", "tag", "to", "the", "metrics" ]

[ "public", "metrics", "registry", "tag", "(", "string", "name", ",", "string", "description", ",", "string", "value", ",", "boolean", "override", ")", "{", "return", "tag", "(", "interns", "info", "(", "name", ",", "description", ")", ",", "value", ",", "override", ")", ";", "}" ]

[ "return", "the", "configured", "message", "body", "converters" ]

[ "public", "list", "<", "http", "message", "converter", "<", "?", ">", ">", "get", "message", "converters", "(", ")", "{", "return", "this", "message", "converters", ";", "}" ]

[ "gets", "current", "profile" ]

[ "protected", "common", "profile", "get", "current", "profile", "(", "final", "http", "servlet", "request", "request", ",", "final", "http", "servlet", "response", "response", ")", "{", "val", "ctx", "=", "new", "j", "e", "e", "context", "(", "request", ",", "response", ",", "this", "oauth", "distributed", "session", "store", ")", ";", "val", "manager", "=", "new", "profile", "manager", "<", "common", "profile", ">", "(", "ctx", ")", ";", "val", "user", "profile", "result", "=", "manager", "get", "(", "true", ")", ";", "if", "(", "user", "profile", "result", "is", "empty", "(", ")", ")", "{", "logger", "info", "(", "\"", "unable", "to", "determine", "the", "user", "profile", "from", "the", "context", "\"", ")", ";", "return", "null", ";", "}", "return", "user", "profile", "result", "get", "(", ")", ";", "}" ]

[ "regression", "test", "for", "hdfs", "-", "13255", "verify", "that", "delete", "fails", "if", "the", "path", "is", "a", "mount", "point", "or", "there", "are", "any", "mount", "point", "under", "the", "path" ]

[ "public", "void", "test", "delete", "mount", "point", "(", ")", "throws", "exception", "{", "try", "{", "mount", "table", "add", "entry", "=", "mount", "table", "new", "instance", "(", "\"", "/", "testdelete", "/", "subdir", "\"", ",", "collections", "singleton", "map", "(", "\"", "ns", "0", "\"", ",", "\"", "/", "testdelete", "/", "subdir", "\"", ")", ")", ";", "assert", "true", "(", "add", "mount", "table", "(", "add", "entry", ")", ")", ";", "nn", "fs", "0", "mkdirs", "(", "new", "path", "(", "\"", "/", "testdelete", "/", "subdir", "\"", ")", ")", ";", "lambda", "test", "utils", "intercept", "(", "access", "control", "exception", "class", ",", "\"", "the", "operation", "is", "not", "allowed", "because", "there", "are", "mount", "points", ":", "\"", "+", "\"", "subdir", "under", "the", "path", ":", "/", "testdelete", "\"", ",", "(", ")", "-", ">", "router", "fs", "delete", "(", "new", "path", "(", "\"", "/", "testdelete", "\"", ")", ",", "true", ")", ")", ";", "lambda", "test", "utils", "intercept", "(", "access", "control", "exception", "class", ",", "\"", "the", "operation", "is", "not", "allowed", "because", "there", "are", "mount", "points", ":", "\"", "+", "\"", "subdir", "under", "the", "path", ":", "/", "testdelete", "\"", ",", "(", ")", "-", ">", "router", "fs", "delete", "(", "new", "path", "(", "\"", "/", "testdelete", "\"", ")", ",", "false", ")", ")", ";", "lambda", "test", "utils", "intercept", "(", "access", "control", "exception", "class", ",", "\"", "the", "operation", "is", "not", "allowed", "because", "the", "path", ":", "\"", "+", "\"", "/", "testdelete", "/", "subdir", "is", "a", "mount", "point", "\"", ",", "(", ")", "-", ">", "router", "fs", "delete", "(", "new", "path", "(", "\"", "/", "testdelete", "/", "subdir", "\"", ")", ",", "true", ")", ")", ";", "lambda", "test", "utils", "intercept", "(", "access", "control", "exception", "class", ",", "\"", "the", "operation", "is", "not", "allowed", "because", "the", "path", ":", "\"", "+", "\"", "/", "testdelete", "/", "subdir", "is", "a", "mount", "point", "\"", ",", "(", ")", "-", ">", "router", "fs", "delete", "(", "new", "path", "(", "\"", "/", "testdelete", "/", "subdir", "\"", ")", ",", "false", ")", ")", ";", "}", "finally", "{", "nn", "fs", "0", "delete", "(", "new", "path", "(", "\"", "/", "testdelete", "\"", ")", ",", "true", ")", ";", "}", "}" ]

[ "finds", "pets", "by", "status", "multiple", "status", "values", "can", "be", "provided", "with", "comma", "separated", "strings" ]

[ "public", "list", "<", "pet", ">", "find", "pets", "by", "status", "(", "@", "query", "param", "(", "\"", "status", "\"", ")", "list", "<", "string", ">", "status", ")", ";" ]

[ "create", "a", "synthetic", "error", "response", "with", "an", "http", "status", "code", "of", "{", "@", "code", "code", "}", "and", "{", "@", "code", "body", "}", "as", "the", "error", "body" ]

[ "public", "static", "<", "t", ">", "response", "<", "t", ">", "error", "(", "int", "code", ",", "response", "body", "body", ")", "{", "objects", "require", "non", "null", "(", "body", ",", "\"", "body", "=", "=", "null", "\"", ")", ";", "if", "(", "code", "<", "400", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "code", "<", "400", ":", "\"", "+", "code", ")", ";", "return", "error", "(", "body", ",", "new", "okhttp", "3", "response", "builder", "(", ")", "/", "/", "body", "(", "new", "ok", "http", "call", "no", "content", "response", "body", "(", "body", "content", "type", "(", ")", ",", "body", "content", "length", "(", ")", ")", ")", "code", "(", "code", ")", "message", "(", "\"", "response", "error", "(", ")", "\"", ")", "protocol", "(", "protocol", "http", "1", "1", ")", "request", "(", "new", "request", "builder", "(", ")", "url", "(", "\"", "http", ":", "/", "/", "localhost", "/", "\"", ")", "build", "(", ")", ")", "build", "(", ")", ")", ";", "}" ]

[ "sets", "the", "list", "of", "custom", "{", "@", "code", "handler", "method", "argument", "resolver", "}", "s", "that", "will", "be", "used", "after", "resolvers", "for", "supported", "argument", "type" ]

[ "public", "void", "set", "custom", "argument", "resolvers", "(", "@", "nullable", "list", "<", "handler", "method", "argument", "resolver", ">", "custom", "argument", "resolvers", ")", "{", "this", "custom", "argument", "resolvers", "clear", "(", ")", ";", "if", "(", "custom", "argument", "resolvers", "!", "=", "null", ")", "{", "this", "custom", "argument", "resolvers", "add", "all", "(", "custom", "argument", "resolvers", ")", ";", "}", "}" ]

[ "calculates", "an", "id", "for", "a", "{", "@", "link", "layout", "output", "}", "see", "{", "@", "link", "layout", "state", "output", "id", "calculator", "#", "calculate", "layout", "output", "base", "id", "(", "layout", "output", ",", "int", ",", "int", ")", "}", "and", "{", "@", "link", "layout", "state", "output", "id", "calculator", "#", "calculate", "id", "(", "long", ",", "int", ")", "}" ]

[ "static", "long", "calculate", "layout", "output", "id", "(", "layout", "output", "layout", "output", ",", "int", "level", ",", "@", "output", "unit", "type", "int", "type", ",", "int", "sequence", ")", "{", "long", "base", "id", "=", "calculate", "layout", "output", "base", "id", "(", "layout", "output", ",", "level", ",", "type", ")", ";", "return", "calculate", "id", "(", "base", "id", ",", "sequence", ")", ";", "}" ]

[ "sets", "a", "specific", "value", "for", "a", "specific", "property", "of", "<", "code", ">", "hikari", "data", "source", "<", "code", ">", "sql", "connections" ]

[ "public", "static", "void", "set", "property", "(", "hikari", "data", "source", "data", "source", ",", "string", "property", ",", "string", "value", ")", "{", "log", "debug", "(", "\"", "setting", "property", "{", "}", "with", "value", "{", "}", "\"", ",", "property", ",", "value", ")", ";", "if", "(", "property", "!", "=", "null", "&", "&", "!", "property", "is", "empty", "(", ")", "&", "&", "value", "!", "=", "null", ")", "{", "data", "source", "add", "data", "source", "property", "(", "property", ",", "value", ")", ";", "}", "}" ]

[ "specify", "the", "encoding", "for", "the", "configured", "sql", "scripts", ",", "if", "different", "from", "the", "platform", "encoding" ]

[ "public", "void", "set", "sql", "script", "encoding", "(", "@", "nullable", "charset", "sql", "script", "encoding", ")", "{", "this", "sql", "script", "encoding", "=", "sql", "script", "encoding", ";", "}" ]

[ "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" ]

[ "public", "void", "delete", "order", "test", "(", ")", "{", "string", "order", "id", "=", "null", ";", "/", "/", "api", "delete", "order", "(", "order", "id", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]

[ "returns", "a", "default", ",", "shared", ",", "single", "-", "thread", "-", "backed", "{", "@", "link", "scheduler", "}", "instance", "for", "work", "requiring", "strongly", "-", "sequential", "execution", "on", "the", "same", "background", "thread", "uses", ":", "event", "loop", "support", "schedulers", "from", "(", "executor", ")", "and", "from", "(", "executor", "service", ")", "with", "delayed", "scheduling", "support", "benchmarks", "that", "pipeline", "data", "from", "some", "thread", "to", "another", "thread", "and", "avoid", "core", "-", "bashing", "of", "computation", "'", "s", "round", "-", "robin", "nature", "unhandled", "errors", "will", "be", "delivered", "to", "the", "scheduler", "thread", "'", "s", "{", "@", "link", "java", "lang", "thread", "uncaught", "exception", "handler", "}", "this", "type", "of", "scheduler", "is", "less", "sensitive", "to", "leaking", "{", "@", "link", "io", "reactivex", "rxjava", "3", "core", "scheduler", "worker", "}", "instances", ",", "although", "not", "disposing", "a", "worker", "that", "has", "timeddelayed", "tasks", "not", "cancelled", "by", "other", "means", "may", "leak", "resources", "andor", "execute", "those", "tasks", "\"", "unexpectedly", "\"", "if", "the", "{", "@", "link", "rx", "java", "plugins", "#", "set", "fail", "on", "non", "blocking", "scheduler", "(", "boolean", ")", "}", "is", "set", "to", "true", ",", "attempting", "to", "execute", "operators", "that", "block", "while", "running", "on", "this", "scheduler", "will", "throw", "an", "{", "@", "link", "illegal", "state", "exception", "}", "you", "can", "control", "certain", "properties", "of", "this", "standard", "scheduler", "via", "system", "properties", "that", "have", "to", "be", "set", "before", "the", "{", "@", "link", "schedulers", "}", "class", "is", "referenced", "in", "your", "code", "supported", "system", "properties", "(", "{", "@", "code", "system", "get", "property", "(", ")", "}", ")", ":", "{", "@", "code", "rx", "3", "single", "-", "priority", "}", "(", "int", ")", ":", "sets", "the", "thread", "priority", "of", "the", "{", "@", "code", "single", "(", ")", "}", "scheduler", ",", "default", "is", "{", "@", "link", "thread", "#", "norm", "priority", "}", "the", "default", "value", "of", "this", "scheduler", "can", "be", "overridden", "at", "initialization", "time", "via", "the", "{", "@", "link", "rx", "java", "plugins", "#", "set", "init", "single", "scheduler", "handler", "(", "io", "reactivex", "rxjava", "3", "functions", "function", ")", "}", "plugin", "method", "note", "that", "due", "to", "possible", "initialization", "cycles", ",", "using", "any", "of", "the", "other", "scheduler", "-", "returning", "methods", "will", "result", "in", "a", "{", "@", "code", "null", "pointer", "exception", "}", "once", "the", "{", "@", "link", "schedulers", "}", "class", "has", "been", "initialized", ",", "you", "can", "override", "the", "returned", "{", "@", "link", "scheduler", "}", "instance", "via", "the", "{", "@", "link", "rx", "java", "plugins", "#", "set", "single", "scheduler", "handler", "(", "io", "reactivex", "rxjava", "3", "functions", "function", ")", "}", "method", "it", "is", "possible", "to", "create", "a", "fresh", "instance", "of", "this", "scheduler", "with", "a", "custom", "thread", "factory", ",", "via", "the", "{", "@", "link", "rx", "java", "plugins", "#", "create", "single", "scheduler", "(", "thread", "factory", ")", "}", "method", "note", "that", "such", "custom", "instances", "require", "a", "manual", "call", "to", "{", "@", "link", "scheduler", "#", "shutdown", "(", ")", "}", "to", "allow", "the", "jvm", "to", "exit", "or", "the", "(", "j2ee", ")", "container", "to", "unload", "properly", "operators", "on", "the", "base", "reactive", "classes", "that", "use", "this", "scheduler", "are", "marked", "with", "the", "&", "#", "64", ";", "{", "@", "link", "io", "reactivex", "rxjava", "3", "annotations", "scheduler", "support", "scheduler", "support", "}", "(", "{", "@", "link", "io", "reactivex", "rxjava", "3", "annotations", "scheduler", "support", "#", "single", "single", "}", ")", "annotation" ]

[ "public", "static", "scheduler", "single", "(", ")", "{", "return", "rx", "java", "plugins", "on", "single", "scheduler", "(", "single", ")", ";", "}" ]

[ "execute", "a", "query", "for", "a", "result", "list", ",", "given", "static", "sql", "uses", "a", "jdbc", "statement", ",", "not", "a", "prepared", "statement", "if", "you", "want", "to", "execute", "a", "static", "query", "with", "a", "prepared", "statement", ",", "use", "the", "overloaded", "{", "@", "code", "query", "for", "list", "}", "method", "with", "{", "@", "code", "null", "}", "as", "argument", "array", "the", "results", "will", "be", "mapped", "to", "a", "list", "(", "one", "entry", "for", "each", "row", ")", "of", "result", "objects", ",", "each", "of", "them", "matching", "the", "specified", "element", "type" ]

[ "<", "t", ">", "list", "<", "t", ">", "query", "for", "list", "(", "string", "sql", ",", "class", "<", "t", ">", "element", "type", ")", "throws", "data", "access", "exception", ";" ]

[ "returns", "true", "if", "the", "specified", "dynamic", "type", "has", "a", "value" ]

[ "public", "boolean", "contains", "dynamic", "value", "(", "long", "type", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "dynamics", "size", "(", ")", ";", "i", "+", "+", ")", "{", "elf", "dynamic", "dyn", "=", "dynamics", "get", "(", "i", ")", ";", "if", "(", "dyn", "get", "tag", "(", ")", "=", "=", "type", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "must", "be", "overridden", "by", "subclasses", "to", "get", "the", "address", "where", "the", "{", "@", "link", "get", "user", "mappings", "protocol", "}", "implementation", "is", "running" ]

[ "protected", "abstract", "inet", "socket", "address", "get", "protocol", "address", "(", "configuration", "conf", ")", "throws", "i", "o", "exception", ";" ]

[ "build", "a", "{", "@", "link", "server", "http", "request", "}", "decorator", "with", "the", "mutated", "properties" ]

[ "server", "http", "request", "build", "(", ")", ";" ]

[ "convert", "the", "replica", "to", "a", "string", "for", "debugging", "purposes", "note", "that", "we", "can", "'", "t", "take", "the", "lock", "here" ]

[ "public", "string", "to", "string", "(", ")", "{", "return", "\"", "short", "circuit", "replica", "{", "\"", "+", "\"", "key", "=", "\"", "+", "key", "+", "\"", ",", "meta", "header", "version", "=", "\"", "+", "meta", "header", "get", "version", "(", ")", "+", "\"", ",", "meta", "header", "checksum", "=", "\"", "+", "meta", "header", "get", "checksum", "(", ")", "+", "\"", ",", "ident", "=", "\"", "+", "\"", "0x", "\"", "+", "integer", "to", "hex", "string", "(", "system", "identity", "hash", "code", "(", "this", ")", ")", "+", "\"", ",", "creation", "time", "ms", "=", "\"", "+", "creation", "time", "ms", "+", "\"", "}", "\"", ";", "}" ]

[ "test", "whether", "the", "initial", "roll", "interval", "is", "set", "correctly" ]

[ "public", "void", "test", "set", "initial", "flush", "time", "(", ")", "{", "rolling", "file", "system", "sink", "rfs", "sink", "=", "new", "rolling", "file", "system", "sink", "(", "1000", ",", "0", ")", ";", "calendar", "calendar", "=", "calendar", "get", "instance", "(", ")", ";", "calendar", "set", "(", "calendar", "millisecond", ",", "0", ")", ";", "calendar", "set", "(", "calendar", "second", ",", "0", ")", ";", "calendar", "set", "(", "calendar", "minute", ",", "0", ")", ";", "calendar", "set", "(", "calendar", "hour", ",", "0", ")", ";", "calendar", "set", "(", "calendar", "day", "of", "year", ",", "1", ")", ";", "calendar", "set", "(", "calendar", "year", ",", "2016", ")", ";", "assert", "null", "(", "\"", "last", "flush", "time", "should", "have", "been", "null", "prior", "to", "calling", "init", "(", ")", "\"", ",", "rfs", "sink", "next", "flush", ")", ";", "rfs", "sink", "set", "initial", "flush", "time", "(", "calendar", "get", "time", "(", ")", ")", ";", "long", "diff", "=", "rfs", "sink", "next", "flush", "get", "time", "in", "millis", "(", ")", "-", "calendar", "get", "time", "in", "millis", "(", ")", ";", "assert", "equals", "(", "\"", "the", "initial", "flush", "time", "was", "calculated", "incorrectly", "\"", ",", "0l", ",", "diff", ")", ";", "calendar", "set", "(", "calendar", "millisecond", ",", "10", ")", ";", "rfs", "sink", "set", "initial", "flush", "time", "(", "calendar", "get", "time", "(", ")", ")", ";", "diff", "=", "rfs", "sink", "next", "flush", "get", "time", "in", "millis", "(", ")", "-", "calendar", "get", "time", "in", "millis", "(", ")", ";", "assert", "equals", "(", "\"", "the", "initial", "flush", "time", "was", "calculated", "incorrectly", "\"", ",", "-", "10l", ",", "diff", ")", ";", "calendar", "set", "(", "calendar", "second", ",", "1", ")", ";", "calendar", "set", "(", "calendar", "millisecond", ",", "10", ")", ";", "rfs", "sink", "set", "initial", "flush", "time", "(", "calendar", "get", "time", "(", ")", ")", ";", "diff", "=", "rfs", "sink", "next", "flush", "get", "time", "in", "millis", "(", ")", "-", "calendar", "get", "time", "in", "millis", "(", ")", ";", "assert", "equals", "(", "\"", "the", "initial", "flush", "time", "was", "calculated", "incorrectly", "\"", ",", "-", "10l", ",", "diff", ")", ";", "/", "/", "try", "again", "with", "a", "random", "offset", "rfs", "sink", "=", "new", "rolling", "file", "system", "sink", "(", "1000", ",", "100", ")", ";", "assert", "null", "(", "\"", "last", "flush", "time", "should", "have", "been", "null", "prior", "to", "calling", "init", "(", ")", "\"", ",", "rfs", "sink", "next", "flush", ")", ";", "calendar", "set", "(", "calendar", "millisecond", ",", "0", ")", ";", "calendar", "set", "(", "calendar", "second", ",", "0", ")", ";", "rfs", "sink", "set", "initial", "flush", "time", "(", "calendar", "get", "time", "(", ")", ")", ";", "diff", "=", "rfs", "sink", "next", "flush", "get", "time", "in", "millis", "(", ")", "-", "calendar", "get", "time", "in", "millis", "(", ")", ";", "assert", "true", "(", "\"", "the", "initial", "flush", "time", "was", "calculated", "incorrectly", ":", "\"", "+", "diff", ",", "(", "diff", "=", "=", "0l", ")", "|", "|", "(", "(", "diff", ">", "-", "1000l", ")", "&", "&", "(", "diff", "<", "-", "900l", ")", ")", ")", ";", "calendar", "set", "(", "calendar", "millisecond", ",", "10", ")", ";", "rfs", "sink", "set", "initial", "flush", "time", "(", "calendar", "get", "time", "(", ")", ")", ";", "diff", "=", "rfs", "sink", "next", "flush", "get", "time", "in", "millis", "(", ")", "-", "calendar", "get", "time", "in", "millis", "(", ")", ";", "assert", "true", "(", "\"", "the", "initial", "flush", "time", "was", "calculated", "incorrectly", ":", "\"", "+", "diff", ",", "(", "diff", ">", "=", "-", "10l", ")", "&", "&", "(", "diff", "<", "=", "0l", ")", "|", "|", "(", "(", "diff", ">", "-", "1000l", ")", "&", "&", "(", "diff", "<", "-", "910l", ")", ")", ")", ";", "calendar", "set", "(", "calendar", "second", ",", "1", ")", ";", "calendar", "set", "(", "calendar", "millisecond", ",", "10", ")", ";", "rfs", "sink", "set", "initial", "flush", "time", "(", "calendar", "get", "time", "(", ")", ")", ";", "diff", "=", "rfs", "sink", "next", "flush", "get", "time", "in", "millis", "(", ")", "-", "calendar", "get", "time", "in", "millis", "(", ")", ";", "assert", "true", "(", "\"", "the", "initial", "flush", "time", "was", "calculated", "incorrectly", ":", "\"", "+", "diff", ",", "(", "diff", ">", "=", "-", "10l", ")", "&", "&", "(", "diff", "<", "=", "0l", ")", "|", "|", "(", "(", "diff", ">", "-", "1000l", ")", "&", "&", "(", "diff", "<", "-", "910l", ")", ")", ")", ";", "/", "/", "now", "try", "pathological", "settings", "rfs", "sink", "=", "new", "rolling", "file", "system", "sink", "(", "1000", ",", "1000000", ")", ";", "assert", "null", "(", "\"", "last", "flush", "time", "should", "have", "been", "null", "prior", "to", "calling", "init", "(", ")", "\"", ",", "rfs", "sink", "next", "flush", ")", ";", "calendar", "set", "(", "calendar", "millisecond", ",", "1", ")", ";", "calendar", "set", "(", "calendar", "second", ",", "0", ")", ";", "rfs", "sink", "set", "initial", "flush", "time", "(", "calendar", "get", "time", "(", ")", ")", ";", "diff", "=", "rfs", "sink", "next", "flush", "get", "time", "in", "millis", "(", ")", "-", "calendar", "get", "time", "in", "millis", "(", ")", ";", "assert", "true", "(", "\"", "the", "initial", "flush", "time", "was", "calculated", "incorrectly", ":", "\"", "+", "diff", ",", "(", "diff", ">", "-", "1000l", ")", "&", "&", "(", "diff", "<", "=", "0l", ")", ")", ";", "}" ]

[ "returns", "a", "hash", "code", "value", "for", "the", "object", ",", "which", "is", "defined", "as", "the", "hash", "code", "of", "the", "path", "name" ]

[ "public", "int", "hash", "code", "(", ")", "{", "return", "super", "hash", "code", "(", ")", ";", "}" ]

[ "sets", "the", "padding", "to", "the", "right", "of", "a", "glyph", "on", "the", "glyph", "page", "to", "allow", "for", "effects", "to", "be", "drawn" ]

[ "public", "void", "set", "padding", "right", "(", "int", "padding", "right", ")", "{", "this", "padding", "right", "=", "padding", "right", ";", "}" ]

[ "set", "the", "message", "body", "converters", "to", "use", "these", "converters", "are", "used", "to", "convert", "from", "and", "to", "http", "requests", "and", "responses" ]

[ "public", "void", "set", "message", "converters", "(", "list", "<", "http", "message", "converter", "<", "?", ">", ">", "message", "converters", ")", "{", "validate", "converters", "(", "message", "converters", ")", ";", "/", "/", "take", "get", "message", "converters", "(", ")", "list", "as", "-", "is", "when", "passed", "in", "here", "if", "(", "this", "message", "converters", "!", "=", "message", "converters", ")", "{", "this", "message", "converters", "clear", "(", ")", ";", "this", "message", "converters", "add", "all", "(", "message", "converters", ")", ";", "}", "}" ]

[ "remove", "(", "x", ",", "null", ")", "returns", "false" ]

[ "public", "void", "test", "remove", "3", "(", ")", "{", "concurrent", "map", "c", "=", "map", "(", ")", ";", "c", "put", "(", "\"", "sadsdf", "\"", ",", "\"", "asdads", "\"", ")", ";", "assert", "false", "(", "c", "remove", "(", "\"", "sadsdf", "\"", ",", "null", ")", ")", ";", "}" ]

[ "test", "for", "network", "host", ":", "ec", "2" ]

[ "public", "void", "test", "network", "host", "ec", "2", "(", ")", "throws", "i", "o", "exception", "{", "resolve", "ec", "2", "(", "\"", "ec", "2", "\"", ",", "inet", "address", "get", "by", "name", "(", "\"", "127", "0", "0", "1", "\"", ")", ")", ";", "}" ]

[ "removes", "the", "shortest", "suffix", "beginning", "with", "'", "'", "from", "the", "basename", "of", "the", "path", "if", "the", "basename", "contains", "no", "'", "'", ",", "the", "filename", "is", "returned", "unchanged", "e", "g", "\"", "foobar", "x", "\"", "-", ">", "\"", "foobar", "\"", "note", "that", "if", "the", "base", "filename", "is", "composed", "entirely", "of", "\"", "\"", ",", "this", "method", "will", "return", "the", "filename", "with", "one", "fewer", "\"", "\"", "in", "the", "base", "filename", ",", "which", "may", "have", "surprising", "effects" ]

[ "public", "static", "path", "remove", "extension", "(", "path", "path", ")", "{", "return", "path", "get", "file", "system", "(", ")", "get", "path", "(", "remove", "extension", "(", "path", "as", "fragment", "(", ")", ")", ")", ";", "}" ]

[ "returns", "a", "map", "of", "{", "@", "link", "index", "id", "}", "to", "a", "collection", "of", "{", "@", "link", "string", "}", "containing", "all", "the", "{", "@", "link", "index", "id", "}", "and", "the", "{", "@", "link", "org", "elasticsearch", "cluster", "metadata", "index", "metadata", "}", "blob", "name", "in", "it", "that", "can", "be", "removed", "after", "removing", "the", "given", "snapshot", "from", "the", "repository", "note", ":", "does", "not", "return", "a", "mapping", "for", "{", "@", "link", "index", "id", "}", "values", "that", "will", "be", "removed", "completely", "from", "the", "repository" ]

[ "public", "map", "<", "index", "id", ",", "collection", "<", "string", ">", ">", "index", "meta", "data", "to", "remove", "after", "removing", "snapshots", "(", "collection", "<", "snapshot", "id", ">", "snapshot", "ids", ")", "{", "collection", "<", "index", "id", ">", "indices", "for", "snapshot", "=", "indices", "to", "update", "after", "removing", "snapshot", "(", "snapshot", "ids", ")", ";", "final", "set", "<", "string", ">", "all", "remaining", "identifiers", "=", "index", "meta", "data", "generations", "lookup", "entry", "set", "(", ")", "stream", "(", ")", "filter", "(", "e", "-", ">", "snapshot", "ids", "contains", "(", "e", "get", "key", "(", ")", ")", "=", "=", "false", ")", "flat", "map", "(", "e", "-", ">", "e", "get", "value", "(", ")", "values", "(", ")", "stream", "(", ")", ")", "map", "(", "index", "meta", "data", "generations", ":", ":", "get", "index", "meta", "blob", "id", ")", "collect", "(", "collectors", "to", "set", "(", ")", ")", ";", "final", "map", "<", "index", "id", ",", "collection", "<", "string", ">", ">", "to", "remove", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "for", "(", "index", "id", "index", "id", ":", "indices", "for", "snapshot", ")", "{", "for", "(", "snapshot", "id", "snapshot", "id", ":", "snapshot", "ids", ")", "{", "final", "string", "identifier", "=", "index", "meta", "data", "generations", "index", "meta", "blob", "id", "(", "snapshot", "id", ",", "index", "id", ")", ";", "if", "(", "all", "remaining", "identifiers", "contains", "(", "identifier", ")", "=", "=", "false", ")", "{", "to", "remove", "compute", "if", "absent", "(", "index", "id", ",", "k", "-", ">", "new", "hash", "set", "<", ">", "(", ")", ")", "add", "(", "identifier", ")", ";", "}", "}", "}", "return", "to", "remove", ";", "}" ]

[ "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", "\"", ")", ";", "}" ]

[ "stores", "a", "float", "array", "in", "the", "table", "at", "the", "given", "row", "and", "column", "note", "-", "all", "values", "in", "a", "given", "column", "must", "be", "of", "the", "same", "type" ]

[ "public", "void", "put", "float", "array", "(", "int", "row", ",", "int", "col", ",", "float", "[", "]", "value", ")", "{", "if", "(", "col", ">", "=", "data", "columns", "length", ")", "{", "grow", "table", "(", "col", "+", "1", ")", ";", "}", "float", "array", "array", "faa", "=", "null", ";", "if", "(", "data", "columns", "[", "col", "]", "=", "=", "null", ")", "{", "faa", "=", "new", "float", "array", "array", "(", ")", ";", "data", "columns", "[", "col", "]", "=", "faa", ";", "}", "else", "{", "faa", "=", "(", "float", "array", "array", ")", "data", "columns", "[", "col", "]", ";", "}", "faa", "put", "(", "row", ",", "value", ")", ";", "}" ]

[ "set", "the", "single", "{", "@", "link", "callback", "}", "to", "use", "ignored", "if", "you", "use", "{", "@", "link", "#", "create", "class", "}" ]

[ "public", "void", "set", "callback", "(", "final", "callback", "callback", ")", "{", "set", "callbacks", "(", "new", "callback", "[", "]", "{", "callback", "}", ")", ";", "}" ]

[ "sets", "the", "failure", "image", "scale", "type", "if", "not", "set", ",", "the", "default", "value", "center", "inside", "will", "be", "used" ]

[ "public", "generic", "drawee", "hierarchy", "builder", "set", "failure", "image", "scale", "type", "(", "@", "nullable", "scaling", "utils", "scale", "type", "failure", "image", "scale", "type", ")", "{", "m", "failure", "image", "scale", "type", "=", "failure", "image", "scale", "type", ";", "return", "this", ";", "}" ]

[ "creates", "a", "new", "big", "-", "endian", "buffer", "whose", "content", "is", "the", "specified", "{", "@", "code", "array", "}", "encoded", "in", "the", "specified", "{", "@", "code", "charset", "}", "the", "new", "buffer", "'", "s", "{", "@", "code", "reader", "index", "}", "and", "{", "@", "code", "writer", "index", "}", "are", "{", "@", "code", "0", "}", "and", "the", "length", "of", "the", "encoded", "string", "respectively" ]

[ "public", "static", "byte", "buf", "copied", "buffer", "(", "char", "[", "]", "array", ",", "charset", "charset", ")", "{", "object", "util", "check", "not", "null", "(", "array", ",", "\"", "array", "\"", ")", ";", "return", "copied", "buffer", "(", "array", ",", "0", ",", "array", "length", ",", "charset", ")", ";", "}" ]

[ "assertions", "on", "the", "cookies", "of", "the", "response" ]

[ "cookie", "assertions", "expect", "cookie", "(", ")", ";" ]

[ "whether", "this", "event", "can", "be", "savedtracked", "by", "cas", "event", "repository" ]

[ "default", "boolean", "should", "save", "event", "(", "cas", "event", "event", ")", "{", "return", "true", ";", "}" ]

[ "get", "capital", "snake" ]

[ "public", "string", "get", "capital", "snake", "(", ")", "{", "return", "capital", "snake", ";", "}" ]

[ "apply", "a", "transaction", "timeout" ]

[ "protected", "void", "apply", "transaction", "timeout", "(", "statement", "statement", ")", "throws", "s", "q", "l", "exception", "{", "statement", "util", "apply", "transaction", "timeout", "(", "statement", ",", "statement", "get", "query", "timeout", "(", ")", ",", "transaction", "get", "timeout", "(", ")", ")", ";", "}" ]

[ "copies", "the", "contents", "of", "src", "to", "dst", ",", "starting", "from", "src", "[", "src", "offset", "]", ",", "copying", "num", "elements", "elements", "the", "{", "@", "link", "buffer", "}", "instance", "'", "s", "{", "@", "link", "buffer", "#", "position", "(", ")", "}", "is", "used", "to", "define", "the", "offset", "into", "the", "buffer", "itself", "the", "position", "will", "stay", "the", "same", ",", "the", "limit", "will", "be", "set", "to", "position", "+", "num", "elements", "<", "b", ">", "the", "buffer", "must", "be", "a", "direct", "buffer", "with", "native", "byte", "order", "no", "error", "checking", "is", "performed", "<", "b", ">" ]

[ "public", "static", "void", "copy", "(", "long", "[", "]", "src", ",", "int", "src", "offset", ",", "buffer", "dst", ",", "int", "num", "elements", ")", "{", "dst", "limit", "(", "dst", "position", "(", ")", "+", "bytes", "to", "elements", "(", "dst", ",", "num", "elements", "<", "<", "3", ")", ")", ";", "copy", "jni", "(", "src", ",", "src", "offset", ",", "dst", ",", "position", "in", "bytes", "(", "dst", ")", ",", "num", "elements", "<", "<", "3", ")", ";", "}" ]

[ "get", "the", "request", "uri" ]

[ "uri", "uri", "(", ")", ";" ]

[ "check", "that", "a", "request", "to", "change", "this", "node", "'", "s", "ha", "state", "is", "valid", "in", "particular", ",", "verifies", "that", ",", "if", "auto", "failover", "is", "enabled", ",", "non", "-", "forced", "requests", "from", "the", "h", "a", "admin", "cli", "are", "rejected", ",", "and", "vice", "versa" ]

[ "private", "void", "check", "ha", "state", "change", "(", "state", "change", "request", "info", "req", ")", "throws", "access", "control", "exception", "{", "switch", "(", "req", "get", "source", "(", ")", ")", "{", "case", "request", "by", "user", ":", "if", "(", "auto", "failover", "enabled", ")", "{", "throw", "new", "access", "control", "exception", "(", "\"", "manual", "failover", "for", "this", "resource", "manager", "is", "disallowed", ",", "\"", "+", "\"", "because", "automatic", "failover", "is", "enabled", "\"", ")", ";", "}", "break", ";", "case", "request", "by", "user", "forced", ":", "if", "(", "auto", "failover", "enabled", ")", "{", "log", "warn", "(", "\"", "allowing", "manual", "failover", "from", "\"", "+", "org", "apache", "hadoop", "ipc", "server", "get", "remote", "address", "(", ")", "+", "\"", "even", "though", "automatic", "failover", "is", "enabled", ",", "because", "the", "user", "\"", "+", "\"", "specified", "the", "force", "flag", "\"", ")", ";", "}", "break", ";", "case", "request", "by", "zkfc", ":", "if", "(", "!", "auto", "failover", "enabled", ")", "{", "throw", "new", "access", "control", "exception", "(", "\"", "request", "from", "zk", "failover", "controller", "at", "\"", "+", "org", "apache", "hadoop", "ipc", "server", "get", "remote", "address", "(", ")", "+", "\"", "denied", "\"", "+", "\"", "since", "automatic", "failover", "is", "not", "enabled", "\"", ")", ";", "}", "break", ";", "}", "}" ]

[ "inserts", "the", "specified", "element", "at", "the", "specified", "position", "in", "the", "array", "shifts", "the", "element", "currently", "at", "that", "position", "(", "if", "any", ")", "and", "any", "subsequent", "elements", "to", "the", "right", "(", "adds", "one", "to", "their", "indices", ")", "this", "method", "returns", "a", "new", "array", "with", "the", "same", "elements", "of", "the", "input", "array", "plus", "the", "given", "element", "on", "the", "specified", "position", "the", "component", "type", "of", "the", "returned", "array", "is", "always", "the", "same", "as", "that", "of", "the", "input", "array", "if", "the", "input", "array", "is", "<", "code", ">", "null", "<", "code", ">", ",", "a", "new", "one", "element", "array", "is", "returned", "whose", "component", "type", "is", "the", "same", "as", "the", "element", "array", "utils", "add", "(", "null", ",", "0", ",", "null", ")", "=", "[", "null", "]", "array", "utils", "add", "(", "null", ",", "0", ",", "\"", "a", "\"", ")", "=", "[", "\"", "a", "\"", "]", "array", "utils", "add", "(", "[", "\"", "a", "\"", "]", ",", "1", ",", "null", ")", "=", "[", "\"", "a", "\"", ",", "null", "]", "array", "utils", "add", "(", "[", "\"", "a", "\"", "]", ",", "1", ",", "\"", "b", "\"", ")", "=", "[", "\"", "a", "\"", ",", "\"", "b", "\"", "]", "array", "utils", "add", "(", "[", "\"", "a", "\"", ",", "\"", "b", "\"", "]", ",", "3", ",", "\"", "c", "\"", ")", "=", "[", "\"", "a", "\"", ",", "\"", "b", "\"", ",", "\"", "c", "\"", "]" ]

[ "public", "static", "<", "t", ">", "t", "[", "]", "add", "(", "t", "[", "]", "array", "1", ",", "int", "index", ",", "t", "[", "]", "array", "2", ")", "{", "class", "clss", ";", "if", "(", "array", "1", "!", "=", "null", ")", "{", "clss", "=", "array", "1", "get", "class", "(", ")", "get", "component", "type", "(", ")", ";", "}", "else", "if", "(", "array", "2", "!", "=", "null", ")", "{", "clss", "=", "array", "2", "get", "class", "(", ")", "get", "component", "type", "(", ")", ";", "}", "else", "{", "return", "(", "t", "[", "]", ")", "new", "object", "[", "]", "{", "null", "}", ";", "}", "return", "(", "t", "[", "]", ")", "real", "add", "arr", "(", "array", "1", ",", "index", ",", "array", "2", ",", "clss", ")", ";", "}" ]

[ "{", "@", "inherit", "doc", "}" ]

[ "public", "void", "set", "character", "stream", "(", "int", "parameter", "index", ",", "reader", "reader", ",", "long", "length", ")", "throws", "s", "q", "l", "exception", "{", "}" ]

[ "these", "tests", "are", "provided", "by", "<", "a", "href", "=", "\"", "https", ":", "publicsuffix", "orglist", "\"", ">", "publicsuffix", "org" ]

[ "@", "test", "public", "void", "public", "suffix", "dot", "org", "test", "cases", "(", ")", "{", "/", "/", "any", "copyright", "is", "dedicated", "to", "the", "public", "domain", "/", "/", "https", ":", "/", "/", "creativecommons", "org", "/", "publicdomain", "/", "zero", "/", "1", "0", "/", "/", "/", "null", "input", "check", "public", "suffix", "(", "null", ",", "null", ")", ";", "/", "/", "mixed", "case", "check", "public", "suffix", "(", "\"", "com", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "example", "com", "\"", ",", "\"", "example", "com", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "ww", "w", "example", "com", "\"", ",", "\"", "example", "com", "\"", ")", ";", "/", "/", "leading", "dot", "check", "public", "suffix", "(", "\"", "com", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "example", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "example", "com", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "example", "example", "\"", ",", "null", ")", ";", "/", "/", "unlisted", "tld", "check", "public", "suffix", "(", "\"", "example", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "example", "example", "\"", ",", "\"", "example", "example", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "b", "example", "example", "\"", ",", "\"", "example", "example", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "a", "b", "example", "example", "\"", ",", "\"", "example", "example", "\"", ")", ";", "/", "/", "listed", ",", "but", "non", "-", "internet", ",", "tld", "/", "/", "check", "public", "suffix", "(", "\"", "local", "\"", ",", "null", ")", ";", "/", "/", "check", "public", "suffix", "(", "\"", "example", "local", "\"", ",", "null", ")", ";", "/", "/", "check", "public", "suffix", "(", "\"", "b", "example", "local", "\"", ",", "null", ")", ";", "/", "/", "check", "public", "suffix", "(", "\"", "a", "b", "example", "local", "\"", ",", "null", ")", ";", "/", "/", "tld", "with", "only", "1", "rule", "check", "public", "suffix", "(", "\"", "biz", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "domain", "biz", "\"", ",", "\"", "domain", "biz", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "b", "domain", "biz", "\"", ",", "\"", "domain", "biz", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "a", "b", "domain", "biz", "\"", ",", "\"", "domain", "biz", "\"", ")", ";", "/", "/", "tld", "with", "some", "2", "-", "level", "rules", "check", "public", "suffix", "(", "\"", "com", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "example", "com", "\"", ",", "\"", "example", "com", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "b", "example", "com", "\"", ",", "\"", "example", "com", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "a", "b", "example", "com", "\"", ",", "\"", "example", "com", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "uk", "com", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "example", "uk", "com", "\"", ",", "\"", "example", "uk", "com", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "b", "example", "uk", "com", "\"", ",", "\"", "example", "uk", "com", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "a", "b", "example", "uk", "com", "\"", ",", "\"", "example", "uk", "com", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "test", "ac", "\"", ",", "\"", "test", "ac", "\"", ")", ";", "/", "/", "tld", "with", "only", "1", "(", "wildcard", ")", "rule", "check", "public", "suffix", "(", "\"", "mm", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "c", "mm", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "b", "c", "mm", "\"", ",", "\"", "b", "c", "mm", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "a", "b", "c", "mm", "\"", ",", "\"", "b", "c", "mm", "\"", ")", ";", "/", "/", "more", "complex", "tld", "check", "public", "suffix", "(", "\"", "jp", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "test", "jp", "\"", ",", "\"", "test", "jp", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "www", "test", "jp", "\"", ",", "\"", "test", "jp", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "ac", "jp", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "test", "ac", "jp", "\"", ",", "\"", "test", "ac", "jp", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "www", "test", "ac", "jp", "\"", ",", "\"", "test", "ac", "jp", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "kyoto", "jp", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "test", "kyoto", "jp", "\"", ",", "\"", "test", "kyoto", "jp", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "ide", "kyoto", "jp", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "b", "ide", "kyoto", "jp", "\"", ",", "\"", "b", "ide", "kyoto", "jp", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "a", "b", "ide", "kyoto", "jp", "\"", ",", "\"", "b", "ide", "kyoto", "jp", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "c", "kobe", "jp", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "b", "c", "kobe", "jp", "\"", ",", "\"", "b", "c", "kobe", "jp", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "a", "b", "c", "kobe", "jp", "\"", ",", "\"", "b", "c", "kobe", "jp", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "city", "kobe", "jp", "\"", ",", "\"", "city", "kobe", "jp", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "www", "city", "kobe", "jp", "\"", ",", "\"", "city", "kobe", "jp", "\"", ")", ";", "/", "/", "tld", "with", "a", "wildcard", "rule", "and", "exceptions", "check", "public", "suffix", "(", "\"", "ck", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "test", "ck", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "b", "test", "ck", "\"", ",", "\"", "b", "test", "ck", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "a", "b", "test", "ck", "\"", ",", "\"", "b", "test", "ck", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "www", "ck", "\"", ",", "\"", "www", "ck", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "www", "www", "ck", "\"", ",", "\"", "www", "ck", "\"", ")", ";", "/", "/", "us", "k12", "check", "public", "suffix", "(", "\"", "us", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "test", "us", "\"", ",", "\"", "test", "us", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "www", "test", "us", "\"", ",", "\"", "test", "us", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "ak", "us", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "test", "ak", "us", "\"", ",", "\"", "test", "ak", "us", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "www", "test", "ak", "us", "\"", ",", "\"", "test", "ak", "us", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "k", "1", "2", "ak", "us", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "test", "k", "1", "2", "ak", "us", "\"", ",", "\"", "test", "k", "1", "2", "ak", "us", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "www", "test", "k", "1", "2", "ak", "us", "\"", ",", "\"", "test", "k", "1", "2", "ak", "us", "\"", ")", ";", "/", "/", "idn", "labels", "check", "public", "suffix", "(", "\"", "com", "cn", "\"", ",", "\"", "com", "cn", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "cn", "\"", ",", "\"", "cn", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "www", "cn", "\"", ",", "\"", "cn", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "shishi", "cn", "\"", ",", "\"", "shishi", "cn", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "cn", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "\"", ",", "\"", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "www", "\"", ",", "\"", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "shishi", "\"", ",", "\"", "shishi", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "\"", ",", "null", ")", ";", "/", "/", "same", "as", "above", ",", "but", "punycoded", "check", "public", "suffix", "(", "\"", "xn", "-", "-", "8", "5x", "7", "2", "2f", "com", "cn", "\"", ",", "\"", "xn", "-", "-", "8", "5x", "7", "2", "2f", "com", "cn", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "xn", "-", "-", "8", "5x", "7", "2", "2f", "xn", "-", "-", "5", "5qx", "5d", "cn", "\"", ",", "\"", "xn", "-", "-", "8", "5x", "7", "2", "2f", "xn", "-", "-", "5", "5qx", "5d", "cn", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "www", "xn", "-", "-", "8", "5x", "7", "2", "2f", "xn", "-", "-", "5", "5qx", "5d", "cn", "\"", ",", "\"", "xn", "-", "-", "8", "5x", "7", "2", "2f", "xn", "-", "-", "5", "5qx", "5d", "cn", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "shishi", "xn", "-", "-", "5", "5qx", "5d", "cn", "\"", ",", "\"", "shishi", "xn", "-", "-", "5", "5qx", "5d", "cn", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "xn", "-", "-", "5", "5qx", "5d", "cn", "\"", ",", "null", ")", ";", "check", "public", "suffix", "(", "\"", "xn", "-", "-", "8", "5x", "7", "2", "2f", "xn", "-", "-", "fiqs", "8s", "\"", ",", "\"", "xn", "-", "-", "8", "5x", "7", "2", "2f", "xn", "-", "-", "fiqs", "8s", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "www", "xn", "-", "-", "8", "5x", "7", "2", "2f", "xn", "-", "-", "fiqs", "8s", "\"", ",", "\"", "xn", "-", "-", "8", "5x", "7", "2", "2f", "xn", "-", "-", "fiqs", "8s", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "shishi", "xn", "-", "-", "fiqs", "8s", "\"", ",", "\"", "shishi", "xn", "-", "-", "fiqs", "8s", "\"", ")", ";", "check", "public", "suffix", "(", "\"", "xn", "-", "-", "fiqs", "8s", "\"", ",", "null", ")", ";", "}" ]

[ "configure", "the", "value", "for", "the", "heartbeat", "settings", "the", "first", "number", "represents", "how", "often", "the", "server", "will", "write", "or", "send", "a", "heartbeat", "the", "second", "is", "how", "often", "the", "client", "should", "write", "0", "means", "no", "heartbeats", "by", "default", "this", "is", "set", "to", "\"", "0", ",", "0", "\"", "unless", "the", "{", "@", "link", "#", "set", "task", "scheduler", "task", "scheduler", "}", "in", "which", "case", "the", "default", "becomes", "\"", "10000", ",", "10000", "\"", "(", "in", "milliseconds", ")" ]

[ "public", "simple", "broker", "registration", "set", "heartbeat", "value", "(", "long", "[", "]", "heartbeat", ")", "{", "this", "heartbeat", "=", "heartbeat", ";", "return", "this", ";", "}" ]

[ "resolve", "the", "given", "string", "value", ",", "for", "example", "parsing", "placeholders" ]

[ "protected", "string", "resolve", "string", "value", "(", "string", "str", "val", ")", "{", "if", "(", "this", "value", "resolver", "=", "=", "null", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "no", "string", "value", "resolver", "specified", "-", "pass", "a", "resolver", "\"", "+", "\"", "object", "into", "the", "constructor", "or", "override", "the", "'", "resolve", "string", "value", "'", "method", "\"", ")", ";", "}", "string", "resolved", "value", "=", "this", "value", "resolver", "resolve", "string", "value", "(", "str", "val", ")", ";", "/", "/", "return", "original", "string", "if", "not", "modified", "return", "(", "str", "val", "equals", "(", "resolved", "value", ")", "?", "str", "val", ":", "resolved", "value", ")", ";", "}" ]

[ "gets", "the", "format", "to", "use", "on", "the", "output", "of", "this", "aggregation" ]

[ "public", "string", "format", "(", ")", "{", "return", "format", ";", "}" ]

[ "logs", "out", "current", "logged", "in", "user", "session" ]

[ "public", "void", "logout", "user", "test", "(", ")", "throws", "api", "exception", "{", "completable", "future", "<", "void", ">", "response", "=", "api", "logout", "user", "(", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]

[ "return", "a", "new", "{", "@", "link", "standard", "environment", "}", "subclasses", "may", "override", "this", "method", "in", "order", "to", "supply", "a", "custom", "{", "@", "link", "configurable", "environment", "}", "implementation" ]

[ "protected", "configurable", "environment", "create", "environment", "(", ")", "{", "return", "new", "standard", "environment", "(", ")", ";", "}" ]

[ "set", "the", "maximum", "number", "of", "parallel", "accesses", "allowed", "-", "1", "indicates", "no", "concurrency", "limit", "at", "all", "in", "principle", ",", "this", "limit", "can", "be", "changed", "at", "runtime", ",", "although", "it", "is", "generally", "designed", "as", "a", "config", "time", "setting", "note", ":", "do", "not", "switch", "between", "-", "1", "and", "any", "concrete", "limit", "at", "runtime", ",", "as", "this", "will", "lead", "to", "inconsistent", "concurrency", "counts", ":", "a", "limit", "of", "-", "1", "effectively", "turns", "off", "concurrency", "counting", "completely" ]

[ "public", "void", "set", "concurrency", "limit", "(", "int", "concurrency", "limit", ")", "{", "this", "concurrency", "throttle", "set", "concurrency", "limit", "(", "concurrency", "limit", ")", ";", "}" ]

[ "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", "\"", ")", ";", "}" ]

[ "derives", "member", "'", "s", "name", "and", "type", "from", "it", "'", "s", "annotations" ]

[ "public", "static", "optional", "<", "string", ">", "get", "parameter", "name", "from", "annotations", "(", "annotation", "[", "]", "member", "annotations", ")", "{", "for", "(", "annotation", "a", ":", "member", "annotations", ")", "{", "if", "(", "a", "instanceof", "query", "param", ")", "{", "return", "optional", "of", "(", "\"", "query", "param", "\"", "+", "(", "(", "query", "param", ")", "a", ")", "value", "(", ")", ")", ";", "}", "else", "if", "(", "a", "instanceof", "path", "param", ")", "{", "return", "optional", "of", "(", "\"", "path", "param", "\"", "+", "(", "(", "path", "param", ")", "a", ")", "value", "(", ")", ")", ";", "}", "else", "if", "(", "a", "instanceof", "header", "param", ")", "{", "return", "optional", "of", "(", "\"", "header", "\"", "+", "(", "(", "header", "param", ")", "a", ")", "value", "(", ")", ")", ";", "}", "else", "if", "(", "a", "instanceof", "cookie", "param", ")", "{", "return", "optional", "of", "(", "\"", "cookie", "\"", "+", "(", "(", "cookie", "param", ")", "a", ")", "value", "(", ")", ")", ";", "}", "else", "if", "(", "a", "instanceof", "form", "param", ")", "{", "return", "optional", "of", "(", "\"", "form", "field", "\"", "+", "(", "(", "form", "param", ")", "a", ")", "value", "(", ")", ")", ";", "}", "else", "if", "(", "a", "instanceof", "context", ")", "{", "return", "optional", "of", "(", "\"", "context", "\"", ")", ";", "}", "else", "if", "(", "a", "instanceof", "matrix", "param", ")", "{", "return", "optional", "of", "(", "\"", "matrix", "param", "\"", "+", "(", "(", "matrix", "param", ")", "a", ")", "value", "(", ")", ")", ";", "}", "}", "return", "optional", "empty", "(", ")", ";", "}" ]

[ "used", "to", "validate", "the", "match", "returned", "from", "a", "compare", "arguments", "call" ]

[ "private", "void", "check", "match", "(", "class", "<", "?", ">", "[", "]", "input", "types", ",", "class", "<", "?", ">", "[", "]", "expected", "types", ",", "standard", "type", "converter", "type", "converter", ",", "arguments", "match", "kind", "expected", "match", "kind", ")", "{", "reflection", "helper", "arguments", "match", "info", "match", "info", "=", "reflection", "helper", "compare", "arguments", "(", "get", "type", "descriptors", "(", "expected", "types", ")", ",", "get", "type", "descriptors", "(", "input", "types", ")", ",", "type", "converter", ")", ";", "if", "(", "expected", "match", "kind", "=", "=", "null", ")", "{", "assert", "that", "(", "match", "info", ")", "as", "(", "\"", "did", "not", "expect", "them", "to", "match", "in", "any", "way", "\"", ")", "is", "null", "(", ")", ";", "}", "else", "{", "assert", "that", "(", "match", "info", ")", "as", "(", "\"", "should", "not", "be", "a", "null", "match", "\"", ")", "is", "not", "null", "(", ")", ";", "}", "if", "(", "expected", "match", "kind", "=", "=", "arguments", "match", "kind", "exact", ")", "{", "assert", "that", "(", "match", "info", "is", "exact", "match", "(", ")", ")", "is", "true", "(", ")", ";", "}", "else", "if", "(", "expected", "match", "kind", "=", "=", "arguments", "match", "kind", "close", ")", "{", "assert", "that", "(", "match", "info", "is", "close", "match", "(", ")", ")", "is", "true", "(", ")", ";", "}", "else", "if", "(", "expected", "match", "kind", "=", "=", "arguments", "match", "kind", "requires", "conversion", ")", "{", "assert", "that", "(", "match", "info", "is", "match", "requiring", "conversion", "(", ")", ")", "as", "(", "\"", "expected", "to", "be", "a", "match", "requiring", "conversion", ",", "but", "was", "\"", "+", "match", "info", ")", "is", "true", "(", ")", ";", "}", "}" ]

[ "returns", "the", "uppercase", "http", "method", "name", "(", "e", "g", ",", "\"", "get", "\"", ",", "\"", "post", "\"", ",", "\"", "head", "\"", ")", "corresponding", "to", "the", "{", "@", "link", "#", "http", "method", "}" ]

[ "public", "final", "string", "get", "http", "method", "string", "(", ")", "{", "return", "get", "string", "for", "http", "method", "(", "http", "method", ")", ";", "}" ]

[ "append", "to", "the", "query", "string", "and", "also", "add", "to", "the", "{", "@", "link", "#", "params", "(", "multi", "value", "map", ")", "}", "request", "parameters", "}", "map", "the", "parameter", "name", "and", "value", "are", "encoded", "when", "they", "are", "added", "to", "the", "query", "string" ]

[ "public", "mock", "http", "servlet", "request", "builder", "query", "params", "(", "multi", "value", "map", "<", "string", ",", "string", ">", "params", ")", "{", "params", "(", "params", ")", ";", "this", "query", "params", "add", "all", "(", "params", ")", ";", "return", "this", ";", "}" ]

[ "drops", "the", "underlying", "database", "table" ]

[ "public", "static", "void", "drop", "table", "(", "database", "db", ",", "boolean", "if", "exists", ")", "{", "string", "sql", "=", "\"", "drop", "table", "\"", "+", "(", "if", "exists", "?", "\"", "if", "exists", "\"", ":", "\"", "\"", ")", "+", "\"", "\\", "\"", "to", "many", "target2", "\\", "\"", "\"", ";", "db", "exec", "s", "q", "l", "(", "sql", ")", ";", "}" ]

[ "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", "\"", ")", ";", "}" ]

[ "called", "when", "any", "particle", "group", "is", "about", "to", "be", "destroyed" ]

[ "void", "say", "goodbye", "(", "particle", "group", "group", ")", ";" ]

[ "tests", "that", "the", "{", "@", "link", "preview", "table", "}", "is", "properly", "loaded", "when", "instructions", "are", "selected" ]

[ "public", "void", "test", "load", "preview", "(", ")", "{", "/", "/", "make", "sure", "it", "has", "the", "number", "of", "rows", "and", "columns", "assert", "equals", "(", "preview", "table", "get", "row", "count", "(", ")", ",", "8", ")", ";", "assert", "equals", "(", "preview", "table", "get", "column", "count", "(", ")", ",", "1", ")", ";", "/", "/", "verify", "the", "contents", "of", "the", "table", "instruction", "table", "data", "object", "obj", "0", "0", "=", "(", "instruction", "table", "data", "object", ")", "preview", "table", "get", "model", "(", ")", "get", "value", "at", "(", "0", ",", "0", ")", ";", "instruction", "table", "data", "object", "obj", "1", "0", "=", "(", "instruction", "table", "data", "object", ")", "preview", "table", "get", "model", "(", ")", "get", "value", "at", "(", "1", ",", "0", ")", ";", "instruction", "table", "data", "object", "obj", "2", "0", "=", "(", "instruction", "table", "data", "object", ")", "preview", "table", "get", "model", "(", ")", "get", "value", "at", "(", "2", ",", "0", ")", ";", "instruction", "table", "data", "object", "obj", "3", "0", "=", "(", "instruction", "table", "data", "object", ")", "preview", "table", "get", "model", "(", ")", "get", "value", "at", "(", "3", ",", "0", ")", ";", "instruction", "table", "data", "object", "obj", "4", "0", "=", "(", "instruction", "table", "data", "object", ")", "preview", "table", "get", "model", "(", ")", "get", "value", "at", "(", "4", ",", "0", ")", ";", "instruction", "table", "data", "object", "obj", "5", "0", "=", "(", "instruction", "table", "data", "object", ")", "preview", "table", "get", "model", "(", ")", "get", "value", "at", "(", "5", ",", "0", ")", ";", "instruction", "table", "data", "object", "obj", "6", "0", "=", "(", "instruction", "table", "data", "object", ")", "preview", "table", "get", "model", "(", ")", "get", "value", "at", "(", "6", ",", "0", ")", ";", "instruction", "table", "data", "object", "obj", "7", "0", "=", "(", "instruction", "table", "data", "object", ")", "preview", "table", "get", "model", "(", ")", "get", "value", "at", "(", "7", ",", "0", ")", ";", "assert", "equals", "(", "obj", "0", "0", "get", "data", "(", ")", "trim", "(", ")", ",", "\"", "47", "\"", ")", ";", "assert", "equals", "(", "obj", "1", "0", "get", "data", "(", ")", "trim", "(", ")", ",", "\"", "57", "\"", ")", ";", "assert", "equals", "(", "obj", "2", "0", "get", "data", "(", ")", "trim", "(", ")", ",", "\"", "8d", "45", "08", "\"", ")", ";", "assert", "equals", "(", "obj", "3", "0", "get", "data", "(", ")", "trim", "(", ")", ",", "\"", "50", "\"", ")", ";", "assert", "equals", "(", "obj", "4", "0", "get", "data", "(", ")", "trim", "(", ")", ",", "\"", "ff", "75", "0c", "\"", ")", ";", "assert", "equals", "(", "obj", "5", "0", "get", "data", "(", ")", "trim", "(", ")", ",", "\"", "e", "8", "84", "2c", "00", "00", "\"", ")", ";", "assert", "equals", "(", "obj", "6", "0", "get", "data", "(", ")", "trim", "(", ")", ",", "\"", "83", "c", "4", "0c", "\"", ")", ";", "assert", "equals", "(", "obj", "7", "0", "get", "data", "(", ")", "trim", "(", ")", ",", "\"", "89", "45", "fc", "\"", ")", ";", "}" ]

[ "write", "value", "from", "bytes" ]

[ "private", "void", "write", "value", "(", "long", "value", "pointer", ",", "data", "output", "view", "output", "view", ")", "throws", "i", "o", "exception", "{", "output", "view", "write", "(", "owning", "state", "map", "help", "get", "bytes", "for", "state", "(", "value", "pointer", ")", ")", ";", "}" ]

[ "get", "the", "partition", "leader", "epoch", "of", "this", "record", "batch" ]

[ "int", "partition", "leader", "epoch", "(", ")", ";" ]

[ "visits", "a", "basic", "block" ]

[ "public", "void", "visit", "block", "(", "basic", "block", "b", ")", ";" ]

[ "returns", "an", "iterator", "over", "all", "occupied", "ranges", "in", "the", "map" ]

[ "public", "index", "range", "iterator", "get", "index", "range", "iterator", "(", "long", "index", ")", "{", "return", "new", "property", "set", "index", "range", "iterator", "(", "map", ",", "index", ")", ";", "}" ]

[ "test", "that", "calling", "{", "@", "link", "s", "3", "a", "input", "stream", "#", "unbuffer", "(", ")", "}", "merges", "a", "stream", "'", "s", "{", "@", "code", "input", "stream", "statistics", "}", "into", "the", "{", "@", "link", "s", "3", "a", "file", "system", "}", "'", "s", "{", "@", "link", "s", "3", "a", "instrumentation", "}", "instance" ]

[ "public", "void", "test", "unbuffer", "stream", "statistics", "(", ")", "throws", "i", "o", "exception", "{", "describe", "(", "\"", "test", "unbuffer", "stream", "statistics", "\"", ")", ";", "/", "/", "validate", "bytes", "read", "is", "updated", "correctly", "s", "3", "a", "file", "system", "fs", "=", "get", "file", "system", "(", ")", ";", "s", "3", "a", "test", "utils", "metric", "diff", "bytes", "read", "=", "new", "s", "3", "a", "test", "utils", "metric", "diff", "(", "fs", ",", "stream", "read", "bytes", ")", ";", "s", "3", "a", "test", "utils", "metric", "diff", "total", "bytes", "read", "=", "new", "s", "3", "a", "test", "utils", "metric", "diff", "(", "fs", ",", "stream", "read", "total", "bytes", ")", ";", "s", "3", "a", "test", "utils", "metric", "diff", "bytes", "read", "in", "close", "=", "new", "s", "3", "a", "test", "utils", "metric", "diff", "(", "fs", ",", "stream", "read", "bytes", "read", "close", ")", ";", "/", "/", "open", "file", ",", "read", "half", "the", "data", ",", "and", "then", "call", "unbuffer", "f", "s", "data", "input", "stream", "input", "stream", "=", "null", ";", "int", "first", "bytes", "to", "read", "=", "8", ";", "int", "second", "bytes", "to", "read", "=", "1", ";", "long", "expected", "final", "bytes", "read", ";", "long", "expected", "total", "bytes", "read", ";", "object", "stream", "stats", "str", ";", "try", "{", "input", "stream", "=", "fs", "open", "(", "dest", ")", ";", "stream", "stats", "str", "=", "demand", "stringify", "i", "o", "statistics", "source", "(", "input", "stream", ")", ";", "log", "info", "(", "\"", "initial", "stream", "statistics", "{", "}", "\"", ",", "stream", "stats", "str", ")", ";", "read", "and", "assert", "bytes", "read", "(", "input", "stream", ",", "first", "bytes", "to", "read", ")", ";", "log", "info", "(", "\"", "stream", "statistics", "after", "read", "{", "}", "\"", ",", "stream", "stats", "str", ")", ";", "input", "stream", "unbuffer", "(", ")", ";", "/", "/", "validate", "that", "calling", "unbuffer", "updates", "the", "input", "stream", "statistics", "bytes", "read", "assert", "diff", "equals", "(", "first", "bytes", "to", "read", ")", ";", "final", "long", "bytes", "in", "unbuffer", "=", "bytes", "read", "in", "close", "diff", "(", ")", ";", "total", "bytes", "read", "assert", "diff", "equals", "(", "first", "bytes", "to", "read", "+", "bytes", "in", "unbuffer", ")", ";", "/", "/", "validate", "that", "calling", "unbuffer", "twice", "in", "a", "row", "updates", "the", "statistics", "/", "/", "correctly", "bytes", "read", "in", "close", "reset", "(", ")", ";", "bytes", "read", "reset", "(", ")", ";", "read", "and", "assert", "bytes", "read", "(", "input", "stream", ",", "second", "bytes", "to", "read", ")", ";", "input", "stream", "unbuffer", "(", ")", ";", "log", "info", "(", "\"", "stream", "statistics", "after", "second", "read", "{", "}", "\"", ",", "stream", "stats", "str", ")", ";", "bytes", "read", "assert", "diff", "equals", "(", "second", "bytes", "to", "read", ")", ";", "final", "long", "bytes", "in", "close", "=", "bytes", "read", "in", "close", "diff", "(", ")", ";", "expected", "final", "bytes", "read", "=", "first", "bytes", "to", "read", "+", "second", "bytes", "to", "read", ";", "expected", "total", "bytes", "read", "=", "expected", "final", "bytes", "read", "+", "bytes", "in", "unbuffer", "+", "bytes", "in", "close", ";", "total", "bytes", "read", "assert", "diff", "equals", "(", "expected", "total", "bytes", "read", ")", ";", "}", "finally", "{", "log", "info", "(", "\"", "closing", "stream", "\"", ")", ";", "i", "o", "utils", "close", "stream", "(", "input", "stream", ")", ";", "}", "log", "info", "(", "\"", "stream", "statistics", "after", "close", "{", "}", "\"", ",", "stream", "stats", "str", ")", ";", "/", "/", "validate", "that", "closing", "the", "file", "does", "not", "further", "change", "the", "statistics", "total", "bytes", "read", "assert", "diff", "equals", "(", "expected", "total", "bytes", "read", ")", ";", "/", "/", "validate", "that", "the", "input", "stream", "stats", "are", "correct", "when", "the", "file", "is", "closed", "s", "3", "a", "input", "stream", "statistics", "stream", "statistics", "=", "(", "(", "s", "3", "a", "input", "stream", ")", "input", "stream", "get", "wrapped", "stream", "(", ")", ")", "get", "s", "3", "a", "stream", "statistics", "(", ")", ";", "assertions", "assert", "that", "(", "stream", "statistics", ")", "described", "as", "(", "\"", "stream", "statistics", "%", "s", "\"", ",", "stream", "statistics", ")", "has", "field", "or", "property", "with", "value", "(", "\"", "bytes", "read", "\"", ",", "expected", "final", "bytes", "read", ")", "has", "field", "or", "property", "with", "value", "(", "\"", "total", "bytes", "read", "\"", ",", "expected", "total", "bytes", "read", ")", ";", "assert", "equals", "(", "\"", "s", "3", "a", "input", "stream", "statistics", "were", "not", "updated", "properly", "in", "\"", "+", "stream", "stats", "str", ",", "expected", "final", "bytes", "read", ",", "stream", "statistics", "get", "bytes", "read", "(", ")", ")", ";", "}" ]

[ "returns", "the", "next", "code", "point", "at", "the", "current", "position", "in", "the", "buffer", "the", "buffer", "'", "s", "position", "will", "be", "incremented", "any", "mark", "set", "on", "this", "buffer", "will", "be", "changed", "by", "this", "method", "!" ]

[ "public", "static", "int", "bytes", "to", "code", "point", "(", "byte", "buffer", "bytes", ")", "{", "bytes", "mark", "(", ")", ";", "byte", "b", "=", "bytes", "get", "(", ")", ";", "bytes", "reset", "(", ")", ";", "int", "extra", "bytes", "to", "read", "=", "bytes", "from", "u", "t", "f", "8", "[", "(", "b", "&", "0x", "f", "f", ")", "]", ";", "if", "(", "extra", "bytes", "to", "read", "<", "0", ")", "return", "-", "1", ";", "/", "/", "trailing", "byte", "!", "int", "ch", "=", "0", ";", "switch", "(", "extra", "bytes", "to", "read", ")", "{", "case", "5", ":", "ch", "+", "=", "(", "bytes", "get", "(", ")", "&", "0x", "f", "f", ")", ";", "ch", "<", "<", "=", "6", ";", "/", "*", "remember", ",", "illegal", "utf", "-", "8", "*", "/", "case", "4", ":", "ch", "+", "=", "(", "bytes", "get", "(", ")", "&", "0x", "f", "f", ")", ";", "ch", "<", "<", "=", "6", ";", "/", "*", "remember", ",", "illegal", "utf", "-", "8", "*", "/", "case", "3", ":", "ch", "+", "=", "(", "bytes", "get", "(", ")", "&", "0x", "f", "f", ")", ";", "ch", "<", "<", "=", "6", ";", "case", "2", ":", "ch", "+", "=", "(", "bytes", "get", "(", ")", "&", "0x", "f", "f", ")", ";", "ch", "<", "<", "=", "6", ";", "case", "1", ":", "ch", "+", "=", "(", "bytes", "get", "(", ")", "&", "0x", "f", "f", ")", ";", "ch", "<", "<", "=", "6", ";", "case", "0", ":", "ch", "+", "=", "(", "bytes", "get", "(", ")", "&", "0x", "f", "f", ")", ";", "}", "ch", "-", "=", "offsets", "from", "u", "t", "f", "8", "[", "extra", "bytes", "to", "read", "]", ";", "return", "ch", ";", "}" ]

[ "performs", "a", "handshake", "between", "the", "client", "handshaker", "and", "server", "handshaker", "using", "a", "transport", "of", "length", "transport", "buffer", "size" ]

[ "static", "void", "perform", "handshake", "(", "int", "transport", "buffer", "size", ",", "handshakers", "handshakers", ")", "throws", "general", "security", "exception", "{", "tsi", "handshaker", "client", "handshaker", "=", "handshakers", "get", "client", "(", ")", ";", "tsi", "handshaker", "server", "handshaker", "=", "handshakers", "get", "server", "(", ")", ";", "byte", "[", "]", "transport", "buffer", "bytes", "=", "new", "byte", "[", "transport", "buffer", "size", "]", ";", "byte", "buffer", "transport", "buffer", "=", "byte", "buffer", "wrap", "(", "transport", "buffer", "bytes", ")", ";", "(", "(", "buffer", ")", "transport", "buffer", ")", "limit", "(", "0", ")", ";", "/", "/", "start", "off", "with", "an", "empty", "buffer", "while", "(", "client", "handshaker", "is", "in", "progress", "(", ")", "|", "|", "server", "handshaker", "is", "in", "progress", "(", ")", ")", "{", "for", "(", "tsi", "handshaker", "handshaker", ":", "new", "tsi", "handshaker", "[", "]", "{", "client", "handshaker", ",", "server", "handshaker", "}", ")", "{", "if", "(", "handshaker", "is", "in", "progress", "(", ")", ")", "{", "/", "/", "process", "any", "bytes", "on", "the", "wire", "if", "(", "transport", "buffer", "has", "remaining", "(", ")", ")", "{", "handshaker", "process", "bytes", "from", "peer", "(", "transport", "buffer", ")", ";", "}", "/", "/", "put", "new", "bytes", "on", "the", "wire", ",", "if", "needed", "if", "(", "handshaker", "is", "in", "progress", "(", ")", ")", "{", "(", "(", "buffer", ")", "transport", "buffer", ")", "clear", "(", ")", ";", "handshaker", "get", "bytes", "to", "send", "to", "peer", "(", "transport", "buffer", ")", ";", "(", "(", "buffer", ")", "transport", "buffer", ")", "flip", "(", ")", ";", "}", "}", "}", "}", "client", "handshaker", "extract", "peer", "(", ")", ";", "server", "handshaker", "extract", "peer", "(", ")", ";", "}" ]

[ "indicate", "a", "fixed", "alignment", "size", "in", "bytes", "which", "should", "be", "used", "for", "zero", "-", "length", "bit", "-", "fields" ]

[ "public", "void", "set", "zero", "length", "boundary", "(", "int", "zero", "length", "boundary", ")", "{", "this", "zero", "length", "boundary", "=", "zero", "length", "boundary", ";", "}" ]

[ "return", "the", "best", "error", "message", "possible", "given", "a", "already", "unwrapped", "exception" ]

[ "public", "static", "string", "get", "detailed", "message", "(", "throwable", "t", ")", "{", "if", "(", "t", "instanceof", "elasticsearch", "exception", ")", "{", "return", "(", "(", "elasticsearch", "exception", ")", "t", ")", "get", "detailed", "message", "(", ")", ";", "}", "return", "t", "get", "message", "(", ")", ";", "}" ]

[ "model", "tests", "for", "read", "only", "first" ]

[ "public", "void", "test", "read", "only", "first", "(", ")", "{", "/", "/", "todo", ":", "test", "read", "only", "first", "}" ]

[ "test", "hsync", "(", "with", "updating", "block", "length", "in", "name", "node", ")", "while", "no", "data", "is", "actually", "written", "yet" ]

[ "public", "void", "h", "sync", "update", "length", "00", "(", ")", "throws", "i", "o", "exception", "{", "configuration", "conf", "=", "new", "hdfs", "configuration", "(", ")", ";", "mini", "d", "f", "s", "cluster", "cluster", "=", "new", "mini", "d", "f", "s", "cluster", "builder", "(", "conf", ")", "num", "data", "nodes", "(", "2", ")", "build", "(", ")", ";", "distributed", "file", "system", "file", "system", "=", "cluster", "get", "file", "system", "(", ")", ";", "try", "{", "path", "path", "=", "new", "path", "(", "f", "name", ")", ";", "f", "s", "data", "output", "stream", "stm", "=", "file", "system", "create", "(", "path", ",", "true", ",", "4096", ",", "(", "short", ")", "2", ",", "append", "test", "util", "block", "size", ")", ";", "system", "out", "println", "(", "\"", "created", "file", "\"", "+", "path", "to", "string", "(", ")", ")", ";", "(", "(", "d", "f", "s", "output", "stream", ")", "stm", "get", "wrapped", "stream", "(", ")", ")", "hsync", "(", "enum", "set", "of", "(", "sync", "flag", "update", "length", ")", ")", ";", "long", "current", "file", "length", "=", "file", "system", "get", "file", "status", "(", "path", ")", "get", "len", "(", ")", ";", "assert", "equals", "(", "0l", ",", "current", "file", "length", ")", ";", "stm", "close", "(", ")", ";", "}", "finally", "{", "file", "system", "close", "(", ")", ";", "cluster", "shutdown", "(", ")", ";", "}", "}" ]

[ "{", "@", "link", "#", "execute", "async", "(", "call", ",", "type", ",", "api", "callback", ")", "}" ]

[ "public", "<", "t", ">", "void", "execute", "async", "(", "call", "call", ",", "api", "callback", "<", "t", ">", "callback", ")", "{", "execute", "async", "(", "call", ",", "null", ",", "callback", ")", ";", "}" ]

[ "test", "the", "property", "'", "prefix", "string", "'" ]

[ "public", "void", "prefix", "string", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "prefix", "string", "}" ]

[ "go", "over", "every", "day", "of", "the", "month", ",", "and", "check", "if", "the", "event", "is", "emitted", "on", "the", "given", "day" ]

[ "private", "void", "test", "all", "days", "with", "default", "observer", "(", "final", "weekday", "special", "day", ",", "final", "event", "event", ")", "{", "final", "var", "default", "observer", "=", "mock", "(", "event", "observer", "class", ")", ";", "final", "var", "observer", "1", "=", "mock", "(", "event", "observer", "class", ")", ";", "final", "var", "observer", "2", "=", "mock", "(", "event", "observer", "class", ")", ";", "final", "var", "emitter", "=", "this", "factory", "with", "default", "observer", "apply", "(", "default", "observer", ")", ";", "emitter", "register", "observer", "(", "observer", "1", ")", ";", "emitter", "register", "observer", "(", "observer", "2", ")", ";", "test", "all", "days", "(", "special", "day", ",", "event", ",", "emitter", ",", "default", "observer", ",", "observer", "1", ",", "observer", "2", ")", ";", "}" ]

[ "test", "the", "property", "'", "prefix", "namespace", "number", "'" ]

[ "public", "void", "prefix", "namespace", "number", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "prefix", "namespace", "number", "}" ]

[ "test", "verifies", "removal", "of", "single", "watcher", "when", "there", "is", "server", "connection" ]

[ "public", "void", "test", "remove", "single", "watcher", "(", "boolean", "use", "async", ")", "throws", "exception", "{", "zk", "1", "create", "(", "\"", "/", "node", "1", "\"", ",", "null", ",", "ids", "open", "acl", "unsafe", ",", "create", "mode", "ephemeral", ")", ";", "zk", "1", "create", "(", "\"", "/", "node", "2", "\"", ",", "null", ",", "ids", "open", "acl", "unsafe", ",", "create", "mode", "ephemeral", ")", ";", "my", "watcher", "w", "1", "=", "new", "my", "watcher", "(", "\"", "/", "node", "1", "\"", ",", "1", ")", ";", "log", "info", "(", "\"", "adding", "data", "watcher", "{", "}", "on", "path", "{", "}", "\"", ",", "w", "1", ",", "\"", "/", "node", "1", "\"", ")", ";", "assert", "not", "null", "(", "zk", "2", "exists", "(", "\"", "/", "node", "1", "\"", ",", "w", "1", ")", ",", "\"", "didn", "'", "t", "set", "data", "watches", "\"", ")", ";", "my", "watcher", "w", "2", "=", "new", "my", "watcher", "(", "\"", "/", "node", "2", "\"", ",", "1", ")", ";", "log", "info", "(", "\"", "adding", "data", "watcher", "{", "}", "on", "path", "{", "}", "\"", ",", "w", "2", ",", "\"", "/", "node", "1", "\"", ")", ";", "assert", "not", "null", "(", "zk", "2", "exists", "(", "\"", "/", "node", "2", "\"", ",", "w", "2", ")", ",", "\"", "didn", "'", "t", "set", "data", "watches", "\"", ")", ";", "remove", "watches", "(", "zk", "2", ",", "\"", "/", "node", "1", "\"", ",", "w", "1", ",", "watcher", "type", "data", ",", "false", ",", "code", "ok", ",", "use", "async", ")", ";", "assert", "equals", "(", "1", ",", "zk", "2", "get", "data", "watches", "(", ")", "size", "(", ")", ",", "\"", "didn", "'", "t", "find", "data", "watcher", "\"", ")", ";", "assert", "equals", "(", "\"", "/", "node", "2", "\"", ",", "zk", "2", "get", "data", "watches", "(", ")", "get", "(", "0", ")", ",", "\"", "didn", "'", "t", "find", "data", "watcher", "\"", ")", ";", "remove", "watches", "(", "zk", "2", ",", "\"", "/", "node", "2", "\"", ",", "w", "2", ",", "watcher", "type", "any", ",", "false", ",", "code", "ok", ",", "use", "async", ")", ";", "assert", "true", "(", "w", "2", "matches", "(", ")", ",", "\"", "didn", "'", "t", "remove", "data", "watcher", "\"", ")", ";", "/", "/", "closing", "session", "should", "remove", "ephemeral", "nodes", "and", "trigger", "data", "/", "/", "watches", "if", "any", "if", "(", "zk", "1", "!", "=", "null", ")", "{", "zk", "1", "close", "(", ")", ";", "zk", "1", "=", "null", ";", "}", "list", "<", "event", "type", ">", "events", "=", "w", "1", "get", "events", "after", "watch", "removal", "(", ")", ";", "assert", "false", "(", "events", "contains", "(", "event", "type", "node", "deleted", ")", ",", "\"", "shouldn", "'", "t", "get", "node", "deleted", "event", "after", "watch", "removal", "\"", ")", ";", "assert", "equals", "(", "0", ",", "events", "size", "(", ")", ",", "\"", "shouldn", "'", "t", "get", "node", "deleted", "event", "after", "watch", "removal", "\"", ")", ";", "}" ]

[ "gets", "the", "app", "cache", "status", "for", "the", "given", "int", "value" ]

[ "public", "static", "app", "cache", "status", "get", "enum", "(", "int", "value", ")", "{", "for", "(", "app", "cache", "status", "status", ":", "app", "cache", "status", "values", "(", ")", ")", "{", "if", "(", "value", "=", "=", "status", "value", "(", ")", ")", "{", "return", "status", ";", "}", "}", "return", "null", ";", "}" ]

[ "called", "when", "a", "media", "source", "started", "loading", "data" ]

[ "default", "void", "on", "load", "started", "(", "event", "time", "event", "time", ",", "load", "event", "info", "load", "event", "info", ",", "media", "load", "data", "media", "load", "data", ")", "{", "}" ]

[ "returns", "the", "name", "of", "the", "current", "master", "node", "in", "the", "cluster" ]

[ "public", "string", "get", "master", "name", "(", ")", "{", "return", "get", "master", "name", "(", "null", ")", ";", "}" ]

[ "checks", "if", "a", "string", "is", "a", "boolean", "or", "not", "and", "what", "type" ]

[ "private", "boolean", "get", "bool", "(", "string", "val", ")", "{", "if", "(", "val", "=", "=", "null", ")", "{", "return", "false", ";", "}", "string", "cleanup", "opt", "=", "string", "utils", "to", "lower", "case", "(", "val", ")", "trim", "(", ")", ";", "if", "(", "cleanup", "opt", "equals", "(", "\"", "true", "\"", ")", "|", "|", "cleanup", "opt", "equals", "(", "\"", "1", "\"", ")", ")", "{", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}" ]

[ "validate", "an", "address", "(", "i", "pv", "4", ",", "i", "pv", "6", ",", "unix", "socket", ")" ]

[ "private", "static", "void", "check", "address", "(", "string", "address", ",", "address", "family", "addr", "family", ")", "{", "object", "util", "check", "not", "null", "(", "addr", "family", ",", "\"", "addr", "family", "\"", ")", ";", "switch", "(", "addr", "family", ")", "{", "case", "af", "unspec", ":", "if", "(", "address", "!", "=", "null", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "unable", "to", "validate", "an", "af", "unspec", "address", ":", "\"", "+", "address", ")", ";", "}", "return", ";", "case", "af", "unix", ":", "object", "util", "check", "not", "null", "(", "address", ",", "\"", "address", "\"", ")", ";", "if", "(", "address", "get", "bytes", "(", "charset", "util", "us", "ascii", ")", "length", ">", "108", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "invalid", "af", "unix", "address", ":", "\"", "+", "address", ")", ";", "}", "return", ";", "}", "object", "util", "check", "not", "null", "(", "address", ",", "\"", "address", "\"", ")", ";", "switch", "(", "addr", "family", ")", "{", "case", "af", "i", "pv", "4", ":", "if", "(", "!", "net", "util", "is", "valid", "ip", "v", "4", "address", "(", "address", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "invalid", "i", "pv", "4", "address", ":", "\"", "+", "address", ")", ";", "}", "break", ";", "case", "af", "i", "pv", "6", ":", "if", "(", "!", "net", "util", "is", "valid", "ip", "v", "6", "address", "(", "address", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "invalid", "i", "pv", "6", "address", ":", "\"", "+", "address", ")", ";", "}", "break", ";", "default", ":", "throw", "new", "illegal", "argument", "exception", "(", "\"", "unexpected", "addr", "family", ":", "\"", "+", "addr", "family", ")", ";", "}", "}" ]

[ "return", "the", "appropriate", "datatype", "for", "a", "given", "c", "primitive", "datatype", "name" ]

[ "public", "static", "data", "type", "get", "c", "primitive", "data", "type", "(", "string", "data", "type", "name", ")", "{", "/", "/", "remove", "any", "excess", "spaces", "if", "(", "data", "type", "name", "contains", "(", "\"", "\"", ")", ")", "{", "data", "type", "name", "=", "data", "type", "name", "trim", "(", ")", "replace", "all", "(", "\"", "\\", "\\", "s", "+", "\"", ",", "\"", "\"", ")", ";", "}", "data", "type", "name", "=", "data", "type", "name", "to", "lower", "case", "(", ")", ";", "return", "c", "primitive", "name", "map", "get", "(", "data", "type", "name", ")", ";", "}" ]

[ "determines", "if", "this", "program", "merge", "currently", "has", "an", "informational", "message" ]

[ "public", "boolean", "has", "info", "message", "(", ")", "{", "return", "(", "info", "msg", "length", "(", ")", ">", "0", ")", ";", "}" ]

[ "returns", "the", "type", "to", "use", "in", "case", "the", "current", "field", "is", "not", "mapped", "in", "an", "index" ]

[ "public", "string", "unmapped", "type", "(", ")", "{", "return", "this", "unmapped", "type", ";", "}" ]

[ "make", "a", "json", "text", "of", "this", "j", "s", "o", "n", "object", "for", "compactness", ",", "no", "whitespace", "is", "added", "if", "this", "would", "not", "result", "in", "a", "syntactically", "correct", "json", "text", ",", "then", "null", "will", "be", "returned", "instead", "warning", ":", "this", "method", "assumes", "that", "the", "signal", "data", "structure", "is", "acyclical" ]

[ "public", "string", "to", "string", "(", ")", "{", "try", "{", "iterator", "keys", "=", "keys", "(", ")", ";", "string", "builder", "sb", "=", "new", "string", "builder", "(", "\"", "{", "\"", ")", ";", "while", "(", "keys", "has", "next", "(", ")", ")", "{", "if", "(", "sb", "length", "(", ")", ">", "1", ")", "{", "sb", "append", "(", "'", ",", "'", ")", ";", "}", "object", "o", "=", "keys", "next", "(", ")", ";", "sb", "append", "(", "quote", "(", "o", "to", "string", "(", ")", ")", ")", ";", "sb", "append", "(", "'", ":", "'", ")", ";", "sb", "append", "(", "value", "to", "string", "(", "this", "map", "get", "(", "o", ")", ")", ")", ";", "}", "sb", "append", "(", "'", "}", "'", ")", ";", "return", "sb", "to", "string", "(", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "return", "null", ";", "}", "}" ]

[ "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", "\"", ")", ";", "}" ]

[ "call", "this", "to", "always", "fully", "qualify", "any", "types", "that", "would", "conflict", "with", "possibly", "nested", "types", "of", "this", "{", "@", "code", "type", "element", "}", "for", "example", "-", "if", "the", "following", "type", "was", "passed", "in", "as", "the", "type", "element", ":", "<", "code", ">", "class", "foo", "{", "class", "nested", "type", "a", "{", "}", "class", "nested", "type", "b", "{", "}", "}", "<", "code", ">", "then", "this", "would", "add", "{", "@", "code", "\"", "nested", "type", "a", "\"", "}", "and", "{", "@", "code", "\"", "nested", "type", "b", "\"", "}", "as", "names", "that", "should", "always", "be", "qualified", "via", "{", "@", "link", "#", "always", "qualify", "(", "string", ")", "}", "this", "way", "they", "would", "avoid", "possible", "import", "conflicts", "when", "this", "java", "file", "is", "written" ]

[ "public", "builder", "avoid", "clashes", "with", "nested", "classes", "(", "type", "element", "type", "element", ")", "{", "check", "argument", "(", "type", "element", "!", "=", "null", ",", "\"", "type", "element", "=", "=", "null", "\"", ")", ";", "for", "(", "type", "element", "nested", "type", ":", "element", "filter", "types", "in", "(", "type", "element", "get", "enclosed", "elements", "(", ")", ")", ")", "{", "always", "qualify", "(", "nested", "type", "get", "simple", "name", "(", ")", "to", "string", "(", ")", ")", ";", "}", "type", "mirror", "superclass", "=", "type", "element", "get", "superclass", "(", ")", ";", "if", "(", "!", "(", "superclass", "instanceof", "no", "type", ")", "&", "&", "superclass", "instanceof", "declared", "type", ")", "{", "type", "element", "superclass", "element", "=", "(", "type", "element", ")", "(", "(", "declared", "type", ")", "superclass", ")", "as", "element", "(", ")", ";", "avoid", "clashes", "with", "nested", "classes", "(", "superclass", "element", ")", ";", "}", "for", "(", "type", "mirror", "superinterface", ":", "type", "element", "get", "interfaces", "(", ")", ")", "{", "if", "(", "superinterface", "instanceof", "declared", "type", ")", "{", "type", "element", "superinterface", "element", "=", "(", "type", "element", ")", "(", "(", "declared", "type", ")", "superinterface", ")", "as", "element", "(", ")", ";", "avoid", "clashes", "with", "nested", "classes", "(", "superinterface", "element", ")", ";", "}", "}", "return", "this", ";", "}" ]

[ "model", "tests", "for", "additional", "properties", "object" ]

[ "public", "void", "test", "additional", "properties", "object", "(", ")", "{", "/", "/", "todo", ":", "test", "additional", "properties", "object", "}" ]

[ "create", "a", "blob", "that", "will", "exist", "for", "a", "single", "app", "session", "an", "app", "session", "is", "defined", "as", "the", "period", "from", "one", "{", "@", "link", "application", "#", "on", "create", "(", ")", "}", "to", "the", "next" ]

[ "public", "uri", "create", "for", "single", "session", "on", "disk", "(", "@", "non", "null", "context", "context", ")", "throws", "i", "o", "exception", "{", "return", "write", "blob", "spec", "to", "disk", "(", "context", ",", "build", "blob", "spec", "(", "storage", "type", "single", "session", "disk", ")", ")", ";", "}" ]

[ "test", "the", "property", "'", "date", "'" ]

[ "public", "void", "date", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "date", "}" ]

[ "a", "query", "that", "allows", "to", "define", "a", "custom", "scoring", "function", "through", "script" ]

[ "public", "static", "script", "score", "query", "builder", "script", "score", "query", "(", "query", "builder", "query", "builder", ",", "script", "script", ")", "{", "return", "new", "script", "score", "query", "builder", "(", "query", "builder", ",", "script", ")", ";", "}" ]

[ "sets", "the", "<", "code", ">", "files", "<", "code", ">", "property" ]

[ "public", "void", "set", "files", "(", "list", "<", "java", "io", "file", ">", "files", ")", "{", "this", "files", "=", "files", ";", "}" ]

[ "set", "the", "value", "of", "the", "'", "{", "@", "code", "target", "}", "'", "attribute", "may", "be", "a", "runtime", "expression" ]

[ "public", "void", "set", "target", "(", "string", "target", ")", "{", "this", "target", "=", "target", ";", "}" ]

[ "write", "a", "row", "entries", "are", "quoted", "if", "the", "bit", "for", "that", "column", "is", "true" ]

[ "public", "csv", "file", "row", "(", "long", "quotes", ",", "object", "columns", ")", "{", "check", "not", "null", "(", "out", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "columns", "length", ";", "i", "+", "+", ")", "{", "if", "(", "i", "!", "=", "0", ")", "{", "out", "write", "(", "separator", ")", ";", "}", "boolean", "to", "quote", "=", "(", "quotes", "&", "1", ")", "=", "=", "1", ";", "/", "/", "unsigned", "right", "shift", "to", "make", "next", "column", "flag", "@", "position", "0", "quotes", "=", "quotes", ">", ">", ">", "1", ";", "if", "(", "to", "quote", ")", "{", "out", "write", "(", "quote", ")", ";", "}", "object", "column", "=", "columns", "[", "i", "]", ";", "out", "write", "(", "column", "!", "=", "null", "?", "column", "to", "string", "(", ")", ":", "\"", "\"", ")", ";", "if", "(", "to", "quote", ")", "{", "out", "write", "(", "quote", ")", ";", "}", "}", "out", "write", "(", "eol", ")", ";", "return", "this", ";", "}" ]

[ "specifies", "table", "schema", "of", "the", "execution", "result" ]

[ "public", "builder", "table", "schema", "(", "table", "schema", "table", "schema", ")", "{", "preconditions", "check", "not", "null", "(", "table", "schema", ",", "\"", "table", "schema", "should", "not", "be", "null", "\"", ")", ";", "this", "table", "schema", "=", "table", "schema", ";", "return", "this", ";", "}" ]