Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "test", "serialization", "of", "outer", "string", "types" ]
[ "completion", "stage", "<", "response", "<", "string", ">", ">", "fake", "outer", "string", "serialize", "(", "@", "retrofit", "2", "http", "body", "string", "body", ")", ";" ]
[ "creates", "a", "{", "@", "code", "string", "tag", "}", "with", "the", "given", "key", "and", "cache", "it", ",", "if", "it", "'", "s", "created", "before", ",", "simply", "return", "it", "without", "creating", "a", "new", "one" ]
[ "public", "static", "abstract", "tag", "<", "string", ">", "of", "key", "(", "final", "string", "key", ")", "{", "return", "tag", "prototypes", "compute", "if", "absent", "(", "key", ",", "string", "tag", ":", ":", "new", ")", ";", "}" ]
[ "this", "method", "can", "be", "called", "by", "a", "model", "'", "s", "methods", "to", "validate", "the", "model", "before", "trying", "to", "retrieve", "a", "particular", "piece", "of", "information", "it", "also", "validates", "that", "the", "ordinal", "value", "doesn", "'", "t", "exceed", "the", "count", "for", "the", "model", "<", "br", ">", "important", ":", "this", "method", "must", "not", "be", "called", "by", "any", "methods", "that", "are", "called", "(", "possibly", "indirectly", ")", "by", "the", "model", "'", "s", "validate", "model", "specific", "info", "(", ")", "method" ]
[ "protected", "void", "check", "validity", "(", "int", "ordinal", ")", "throws", "invalid", "data", "type", "exception", "{", "check", "validity", "(", ")", ";", "if", "(", "ordinal", "<", "0", "|", "|", "ordinal", ">", "=", "get", "count", "(", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "ordinal", "+", "\"", "is", "not", "a", "valid", "ordinal", "for", "\"", "+", "get", "name", "(", ")", "+", "\"", "data", "type", "at", "\"", "+", "get", "address", "(", ")", "+", "\"", "in", "\"", "+", "get", "program", "(", ")", "+", "\"", "\"", ")", ";", "}", "}" ]
[ "sets", "the", "size", "of", "the", "label", "text", "in", "density", "pixels", "min", "=", "6f", ",", "max", "=", "2", "4f", ",", "default", "1", "0f" ]
[ "public", "void", "set", "text", "size", "(", "float", "size", ")", "{", "if", "(", "size", ">", "2", "4f", ")", "size", "=", "2", "4f", ";", "if", "(", "size", "<", "6f", ")", "size", "=", "6f", ";", "m", "text", "size", "=", "utils", "convert", "dp", "to", "pixel", "(", "size", ")", ";", "}" ]
[ "test", "that", "get", "invalidate", "blocks", "observes", "the", "maxlimit" ]
[ "public", "void", "test", "get", "invalidate", "blocks", "(", ")", "throws", "exception", "{", "final", "int", "max", "blocks", "=", "10", ";", "final", "int", "remaining", "blocks", "=", "2", ";", "final", "int", "max", "limit", "=", "max", "blocks", "-", "remaining", "blocks", ";", "datanode", "descriptor", "dd", "=", "d", "f", "s", "test", "util", "get", "local", "datanode", "descriptor", "(", ")", ";", "array", "list", "<", "block", ">", "block", "list", "=", "new", "array", "list", "<", "block", ">", "(", "max", "blocks", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "max", "blocks", ";", "i", "+", "+", ")", "{", "block", "list", "add", "(", "new", "block", "(", "i", ",", "0", ",", "generation", "stamp", "last", "reserved", "stamp", ")", ")", ";", "}", "dd", "add", "blocks", "to", "be", "invalidated", "(", "block", "list", ")", ";", "block", "[", "]", "bc", "=", "dd", "get", "invalidate", "blocks", "(", "max", "limit", ")", ";", "assert", "equals", "(", "bc", "length", ",", "max", "limit", ")", ";", "bc", "=", "dd", "get", "invalidate", "blocks", "(", "max", "limit", ")", ";", "assert", "equals", "(", "bc", "length", ",", "remaining", "blocks", ")", ";", "}" ]
[ "sets", "radius", "to", "be", "used", "for", "rounding" ]
[ "public", "void", "set", "radius", "(", "float", "radius", ")", "{", "arrays", "fill", "(", "m", "radii", ",", "radius", ")", ";", "update", "path", "(", ")", ";", "invalidate", "self", "(", ")", ";", "}" ]
[ "sets", "the", "extension", "renderer", "mode", ",", "which", "determines", "if", "and", "how", "available", "extension", "renderers", "are", "used", "note", "that", "extensions", "must", "be", "included", "in", "the", "application", "build", "for", "them", "to", "be", "considered", "available", "the", "default", "value", "is", "{", "@", "link", "#", "extension", "renderer", "mode", "off", "}" ]
[ "public", "default", "renderers", "factory", "set", "extension", "renderer", "mode", "(", "@", "extension", "renderer", "mode", "int", "extension", "renderer", "mode", ")", "{", "this", "extension", "renderer", "mode", "=", "extension", "renderer", "mode", ";", "return", "this", ";", "}" ]
[ "returns", "the", "system", "table", "for", "the", "specified", "table", "name", ",", "if", "one", "exists", "the", "system", "tables", "handled", "via", "{", "@", "link", "#", "get", "system", "table", "}", "differ", "form", "those", "returned", "by", "{", "@", "link", "connector", "#", "get", "system", "tables", "(", ")", "}", "the", "former", "mechanism", "allows", "dynamic", "resolution", "of", "system", "tables", ",", "while", "the", "latter", "is", "based", "on", "static", "list", "of", "system", "tables", "built", "during", "startup" ]
[ "default", "optional", "<", "system", "table", ">", "get", "system", "table", "(", "connector", "session", "session", ",", "schema", "table", "name", "table", "name", ")", "{", "return", "optional", "empty", "(", ")", ";", "}" ]
[ "minimum", "session", "timeout", "in", "milliseconds", ",", "-", "1", "if", "unset" ]
[ "public", "int", "get", "min", "session", "timeout", "(", ")", "{", "return", "min", "session", "timeout", ";", "}" ]
[ "called", "for", "every", "new", "file", "found", "in", "the", "watched", "directory" ]
[ "default", "void", "on", "file", "created", "(", "path", "file", ")", "{", "}" ]
[ "set", "the", "result", "register" ]
[ "protected", "void", "set", "result", "(", "register", "spec", "result", ")", "{", "if", "(", "result", "=", "=", "null", ")", "{", "throw", "new", "null", "pointer", "exception", "(", "\"", "result", "=", "=", "null", "\"", ")", ";", "}", "this", "result", "=", "result", ";", "}" ]
[ "return", "the", "terminating", "name", "of", "this", "category", "path" ]
[ "public", "string", "get", "name", "(", ")", "{", "return", "name", ";", "}" ]
[ "returns", "true", "if", "importing", "to", "an", "existing", "program", "importing", "to", "an", "existing", "program", "creates", "a", "new", "set", "of", "potential", "conflicts", "for", "example", ",", "memory", "block", "may", "collide", "when", "this", "options", "is", "true", ",", "additional", "options", "are", "visible" ]
[ "boolean", "is", "add", "to", "program", "(", ")", "{", "return", "add", "to", "program", ";", "}" ]
[ "reads", "the", "cie", "augmentation", "data", "and", "holds", "it", "in", "this", "class", "this", "block", "of", "data", "is", "defined", "by", "the", "contents", "of", "the", "augmentation", "string", "and", "is", "only", "present", "if", "the", "augmentation", "string", "contains", "the", "character", "'", "z", "'", "length", "of", "this", "string", "is", "given", "by", "the", "augmentation", "length" ]
[ "private", "address", "grab", "augmentation", "data", "(", "address", "addr", ")", "throws", "memory", "access", "exception", "{", "/", "*", "*", "copies", "the", "augmentation", "data", "at", "the", "specified", "address", "into", "<", "code", ">", "augmentation", "data", "<", "/", "code", ">", "*", "so", "it", "can", "be", "processed", "*", "/", "augmentation", "data", "=", "new", "byte", "[", "augmentation", "data", "length", "]", ";", "int", "num", "bytes", "read", "=", "program", "get", "memory", "(", ")", "get", "bytes", "(", "addr", ",", "augmentation", "data", ")", ";", "cur", "size", "+", "=", "num", "bytes", "read", ";", "return", "addr", "add", "(", "num", "bytes", "read", ")", ";", "}" ]
[ "returns", "the", "last", "modification", "time", "of", "the", "file", ",", "in", "milliseconds", "since", "the", "unix", "epoch", ",", "of", "the", "file", "denoted", "by", "the", "current", "path", ",", "following", "symbolic", "links", "caveat", ":", "many", "filesystems", "store", "file", "times", "in", "seconds", ",", "so", "do", "not", "rely", "on", "the", "millisecond", "precision" ]
[ "public", "long", "get", "last", "modified", "time", "(", ")", "throws", "i", "o", "exception", "{", "return", "file", "system", "get", "last", "modified", "time", "(", "this", ",", "true", ")", ";", "}" ]
[ "returns", "a", "map", "of", "{", "@", "link", "http", "server", "transport", "}", "suppliers", "see", "{", "@", "link", "org", "elasticsearch", "common", "network", "network", "module", "#", "http", "type", "setting", "}", "to", "configure", "a", "specific", "implementation" ]
[ "default", "map", "<", "string", ",", "supplier", "<", "http", "server", "transport", ">", ">", "get", "http", "transports", "(", "settings", "settings", ",", "thread", "pool", "thread", "pool", ",", "big", "arrays", "big", "arrays", ",", "page", "cache", "recycler", "page", "cache", "recycler", ",", "circuit", "breaker", "service", "circuit", "breaker", "service", ",", "named", "x", "content", "registry", "x", "content", "registry", ",", "network", "service", "network", "service", ",", "http", "server", "transport", "dispatcher", "dispatcher", ",", "cluster", "settings", "cluster", "settings", ")", "{", "return", "collections", "empty", "map", "(", ")", ";", "}" ]
[ "checks", "the", "correct", "result", "if", "a", "get", "operation", "fails", "during", "the", "lookup", "of", "the", "file" ]
[ "private", "void", "test", "get", "fails", "during", "lookup", "(", "@", "nullable", "final", "job", "i", "d", "job", "id", "1", ",", "@", "nullable", "final", "job", "i", "d", "job", "id", "2", ",", "blob", "key", "blob", "type", "blob", "type", ")", "throws", "i", "o", "exception", "{", "final", "configuration", "config", "=", "new", "configuration", "(", ")", ";", "config", "set", "string", "(", "blob", "server", "options", "storage", "directory", ",", "temporary", "folder", "new", "folder", "(", ")", "get", "absolute", "path", "(", ")", ")", ";", "try", "(", "blob", "server", "server", "=", "new", "blob", "server", "(", "config", ",", "new", "void", "blob", "store", "(", ")", ")", ")", "{", "server", "start", "(", ")", ";", "byte", "[", "]", "data", "=", "new", "byte", "[", "2000000", "]", ";", "rnd", "next", "bytes", "(", "data", ")", ";", "/", "/", "put", "content", "addressable", "(", "like", "libraries", ")", "blob", "key", "key", "=", "put", "(", "server", ",", "job", "id", "1", ",", "data", ",", "blob", "type", ")", ";", "assert", "not", "null", "(", "key", ")", ";", "/", "/", "delete", "file", "to", "make", "sure", "that", "get", "requests", "fail", "file", "blob", "file", "=", "server", "get", "storage", "location", "(", "job", "id", "1", ",", "key", ")", ";", "assert", "true", "(", "blob", "file", "delete", "(", ")", ")", ";", "/", "/", "issue", "a", "get", "request", "that", "fails", "verify", "deleted", "(", "server", ",", "job", "id", "1", ",", "key", ")", ";", "/", "/", "add", "the", "same", "data", "under", "a", "second", "job", "id", "blob", "key", "key", "2", "=", "put", "(", "server", ",", "job", "id", "2", ",", "data", ",", "blob", "type", ")", ";", "assert", "not", "null", "(", "key", "2", ")", ";", "verify", "key", "different", "hash", "equals", "(", "key", ",", "key", "2", ")", ";", "/", "/", "request", "for", "job", "id", "2", "should", "succeed", "get", "(", "server", ",", "job", "id", "2", ",", "key", "2", ")", ";", "/", "/", "request", "for", "job", "id", "1", "should", "still", "fail", "verify", "deleted", "(", "server", ",", "job", "id", "1", ",", "key", ")", ";", "/", "/", "same", "checks", "as", "for", "job", "id", "1", "but", "for", "job", "id", "2", "should", "also", "work", ":", "blob", "file", "=", "server", "get", "storage", "location", "(", "job", "id", "2", ",", "key", "2", ")", ";", "assert", "true", "(", "blob", "file", "delete", "(", ")", ")", ";", "verify", "deleted", "(", "server", ",", "job", "id", "2", ",", "key", "2", ")", ";", "}", "}" ]
[ "tests", "the", "operation", "succeeds", "second", "time", "after", "connect", "timeout", "exception" ]
[ "public", "void", "test", "client", "retries", "succeeds", "second", "time", "(", ")", "throws", "exception", "{", "configuration", "conf", "=", "new", "configuration", "(", ")", ";", "conf", "set", "int", "(", "common", "configuration", "keys", "public", "kms", "client", "failover", "max", "retries", "key", ",", "3", ")", ";", "k", "m", "s", "client", "provider", "p", "1", "=", "mock", "(", "k", "m", "s", "client", "provider", "class", ")", ";", "when", "(", "p", "1", "create", "key", "(", "mockito", "any", "string", "(", ")", ",", "mockito", "any", "(", "options", "class", ")", ")", ")", "then", "throw", "(", "new", "connect", "timeout", "exception", "(", "\"", "p", "1", "\"", ")", ")", "then", "return", "(", "new", "k", "m", "s", "client", "provider", "k", "m", "s", "key", "version", "(", "\"", "test", "3", "\"", ",", "\"", "v", "1", "\"", ",", "new", "byte", "[", "0", "]", ")", ")", ";", "k", "m", "s", "client", "provider", "p", "2", "=", "mock", "(", "k", "m", "s", "client", "provider", "class", ")", ";", "when", "(", "p", "2", "create", "key", "(", "mockito", "any", "string", "(", ")", ",", "mockito", "any", "(", "options", "class", ")", ")", ")", "then", "throw", "(", "new", "connect", "timeout", "exception", "(", "\"", "p", "2", "\"", ")", ")", ";", "when", "(", "p", "1", "get", "k", "m", "s", "url", "(", ")", ")", "then", "return", "(", "\"", "p", "1", "\"", ")", ";", "when", "(", "p", "2", "get", "k", "m", "s", "url", "(", ")", ")", "then", "return", "(", "\"", "p", "2", "\"", ")", ";", "load", "balancing", "k", "m", "s", "client", "provider", "kp", "=", "new", "load", "balancing", "k", "m", "s", "client", "provider", "(", "new", "k", "m", "s", "client", "provider", "[", "]", "{", "p", "1", ",", "p", "2", "}", ",", "0", ",", "conf", ")", ";", "try", "{", "kp", "create", "key", "(", "\"", "test", "3", "\"", ",", "new", "options", "(", "conf", ")", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "fail", "(", "\"", "provider", "p", "1", "should", "have", "answered", "the", "request", "second", "time", "\"", ")", ";", "}", "verify", "(", "p", "1", ",", "mockito", "times", "(", "2", ")", ")", "create", "key", "(", "mockito", "eq", "(", "\"", "test", "3", "\"", ")", ",", "mockito", "any", "(", "options", "class", ")", ")", ";", "verify", "(", "p", "2", ",", "mockito", "times", "(", "1", ")", ")", "create", "key", "(", "mockito", "eq", "(", "\"", "test", "3", "\"", ")", ",", "mockito", "any", "(", "options", "class", ")", ")", ";", "}" ]
[ "the", "main", "method", "for", "running", "it", "as", "a", "stand", "alone", "command" ]
[ "public", "static", "void", "main", "(", "string", "[", "]", "argv", ")", "throws", "exception", "{", "system", "exit", "(", "tool", "runner", "run", "(", "null", ",", "new", "bailey", "borwein", "plouffe", "(", ")", ",", "argv", ")", ")", ";", "}" ]
[ "the", "evaluator", "cleans", "up", "leading", "and", "trailing", "whitespace", ",", "but", "not", "duplicate", "spaces" ]
[ "public", "void", "test", "trailing", "whitespace", "(", ")", "{", "evaluates", "to", "(", "datamodel", "make", "string", "value", "(", "\"", "dirty", "\"", ")", ",", "\"", "dirty", "\\", "t", "\"", ")", ";", "}" ]
[ "creates", "a", "notification", "channel", "that", "notifications", "can", "be", "posted", "to", "see", "{", "@", "link", "notification", "channel", "}", "and", "{", "@", "link", "notification", "manager", "#", "create", "notification", "channel", "(", "notification", "channel", ")", "}", "for", "details" ]
[ "public", "static", "void", "create", "notification", "channel", "(", "context", "context", ",", "string", "id", ",", "@", "string", "res", "int", "name", "resource", "id", ",", "@", "string", "res", "int", "description", "resource", "id", ",", "@", "importance", "int", "importance", ")", "{", "if", "(", "util", "sdk", "int", ">", "=", "26", ")", "{", "notification", "manager", "notification", "manager", "=", "check", "not", "null", "(", "(", "notification", "manager", ")", "context", "get", "system", "service", "(", "context", "notification", "service", ")", ")", ";", "notification", "channel", "channel", "=", "new", "notification", "channel", "(", "id", ",", "context", "get", "string", "(", "name", "resource", "id", ")", ",", "importance", ")", ";", "if", "(", "description", "resource", "id", "!", "=", "0", ")", "{", "channel", "set", "description", "(", "context", "get", "string", "(", "description", "resource", "id", ")", ")", ";", "}", "notification", "manager", "create", "notification", "channel", "(", "channel", ")", ";", "}", "}" ]
[ "<", "code", ">", "optional", "double", "money", "=", "1", ";", "<", "code", ">" ]
[ "public", "builder", "set", "money", "(", "double", "value", ")", "{", "bit", "field", "0", "|", "=", "0x", "0", "0", "0", "0", "0", "0", "0", "1", ";", "money", "=", "value", ";", "on", "changed", "(", ")", ";", "return", "this", ";", "}" ]
[ "set", "steady", "fair", "share", "for", "queue" ]
[ "public", "void", "set", "steady", "fair", "share", "(", "resource", "resource", ")", "{", "steady", "fair", "share", "m", "b", "set", "(", "resource", "get", "memory", "size", "(", ")", ")", ";", "steady", "fair", "share", "v", "cores", "set", "(", "resource", "get", "virtual", "cores", "(", ")", ")", ";", "if", "(", "custom", "resources", "!", "=", "null", ")", "{", "custom", "resources", "set", "steady", "fair", "share", "(", "resource", ")", ";", "}", "}" ]
[ "similar", "to", "{", "@", "link", "catalog", "source", "table", "#", "to", "rel", "(", "rel", "opt", "table", "to", "rel", "context", ")", "}", ",", "converts", "a", "given", "{", "@", "link", "dynamic", "table", "sink", "}", "to", "a", "{", "@", "link", "rel", "node", "}", "it", "adds", "helper", "projections", "if", "necessary" ]
[ "public", "static", "rel", "node", "to", "rel", "(", "flink", "rel", "builder", "rel", "builder", ",", "rel", "node", "input", ",", "catalog", "sink", "modify", "operation", "sink", "operation", ",", "dynamic", "table", "sink", "sink", ",", "catalog", "table", "table", ")", "{", "final", "flink", "type", "factory", "type", "factory", "=", "shortcut", "utils", "unwrap", "type", "factory", "(", "rel", "builder", ")", ";", "final", "table", "schema", "schema", "=", "table", "get", "schema", "(", ")", ";", "/", "/", "1", "prepare", "table", "sink", "prepare", "dynamic", "sink", "(", "sink", "operation", ",", "sink", ",", "table", ")", ";", "/", "/", "2", "validate", "the", "query", "schema", "to", "the", "sink", "'", "s", "table", "schema", "and", "apply", "cast", "if", "possible", "final", "rel", "node", "query", "=", "validate", "schema", "and", "apply", "implicit", "cast", "(", "input", ",", "schema", ",", "sink", "operation", "get", "table", "identifier", "(", ")", ",", "type", "factory", ")", ";", "rel", "builder", "push", "(", "query", ")", ";", "/", "/", "3", "convert", "the", "sink", "'", "s", "table", "schema", "to", "the", "consumed", "data", "type", "of", "the", "sink", "final", "list", "<", "integer", ">", "metadata", "columns", "=", "extract", "persisted", "metadata", "columns", "(", "schema", ")", ";", "if", "(", "!", "metadata", "columns", "is", "empty", "(", ")", ")", "{", "push", "metadata", "projection", "(", "rel", "builder", ",", "type", "factory", ",", "schema", ",", "sink", ")", ";", "}", "final", "rel", "node", "final", "query", "=", "rel", "builder", "build", "(", ")", ";", "return", "logical", "sink", "create", "(", "final", "query", ",", "sink", "operation", "get", "table", "identifier", "(", ")", ",", "table", ",", "sink", ",", "sink", "operation", "get", "static", "partitions", "(", ")", ")", ";", "}" ]
[ "leave", "safe", "mode" ]
[ "void", "leave", "safe", "mode", "(", "boolean", "force", ")", "{", "write", "lock", "(", ")", ";", "try", "{", "if", "(", "!", "is", "in", "safe", "mode", "(", ")", ")", "{", "name", "node", "state", "change", "log", "info", "(", "\"", "state", "*", "safe", "mode", "is", "already", "off", "\"", ")", ";", "return", ";", "}", "if", "(", "block", "manager", "leave", "safe", "mode", "(", "force", ")", ")", "{", "set", "manual", "and", "resource", "low", "safe", "mode", "(", "false", ",", "false", ")", ";", "start", "secret", "manager", "if", "necessary", "(", ")", ";", "}", "}", "finally", "{", "write", "unlock", "(", "\"", "leave", "safe", "mode", "\"", ",", "get", "lock", "report", "info", "supplier", "(", "null", ")", ")", ";", "}", "}" ]
[ "test", "case", "for", "an", "empty", "edit", "log", "from", "a", "prior", "version", "of", "hadoop" ]
[ "public", "void", "test", "pre", "tx", "id", "edit", "log", "no", "edits", "(", ")", "throws", "exception", "{", "f", "s", "namesystem", "namesys", "=", "mockito", "mock", "(", "f", "s", "namesystem", "class", ")", ";", "namesys", "dir", "=", "mockito", "mock", "(", "f", "s", "directory", "class", ")", ";", "long", "num", "edits", "=", "test", "load", "(", "string", "utils", "hex", "string", "to", "byte", "(", "\"", "ffffffed", "\"", ")", ",", "/", "/", "just", "version", "number", "namesys", ")", ";", "assert", "equals", "(", "0", ",", "num", "edits", ")", ";", "}" ]
[ "get", "the", "set", "of", "target", "expressions" ]
[ "public", "set", "<", "target", "expression", ">", "get", "target", "expressions", "(", ")", "{", "return", "target", "expressions", ";", "}" ]
[ "test", "if", "the", "avro", "input", "format", "is", "able", "to", "properly", "read", "data", "from", "an", "avro", "file", "as", "a", "generic", "record" ]
[ "public", "void", "test", "deserialization", "generic", "record", "(", ")", "throws", "i", "o", "exception", "{", "configuration", "parameters", "=", "new", "configuration", "(", ")", ";", "avro", "input", "format", "<", "generic", "record", ">", "format", "=", "new", "avro", "input", "format", "<", ">", "(", "new", "path", "(", "test", "file", "get", "absolute", "path", "(", ")", ")", ",", "generic", "record", "class", ")", ";", "do", "test", "deserialization", "generic", "record", "(", "format", ",", "parameters", ")", ";", "}" ]
[ "send", "message", "back", "to", "the", "broker", "whose", "name", "is", "<", "code", ">", "broker", "name", "<", "code", ">", "and", "the", "message", "will", "be", "re", "-", "delivered", "in", "future", "this", "method", "will", "be", "removed", "or", "it", "'", "s", "visibility", "will", "be", "changed", "in", "a", "certain", "version", "after", "april", "5", ",", "2020", ",", "so", "please", "do", "not", "use", "this", "method" ]
[ "public", "void", "send", "message", "back", "(", "message", "ext", "msg", ",", "int", "delay", "level", ",", "string", "broker", "name", ")", "throws", "remoting", "exception", ",", "m", "q", "broker", "exception", ",", "interrupted", "exception", ",", "m", "q", "client", "exception", "{", "msg", "set", "topic", "(", "with", "namespace", "(", "msg", "get", "topic", "(", ")", ")", ")", ";", "this", "default", "m", "q", "push", "consumer", "impl", "send", "message", "back", "(", "msg", ",", "delay", "level", ",", "broker", "name", ")", ";", "}" ]
[ "returns", "a", "set", "of", "custom", "meta", "data", "types", "when", "any", "custom", "metadata", "for", "the", "cluster", "has", "changed", "between", "the", "previous", "cluster", "state", "and", "the", "new", "cluster", "state", "custom", "meta", "data", "types", "are", "returned", "iff", "they", "have", "been", "added", ",", "updated", "or", "removed", "between", "the", "previous", "and", "the", "current", "state" ]
[ "public", "set", "<", "string", ">", "changed", "custom", "metadata", "set", "(", ")", "{", "set", "<", "string", ">", "result", "=", "new", "hash", "set", "<", ">", "(", ")", ";", "immutable", "open", "map", "<", "string", ",", "metadata", "custom", ">", "current", "customs", "=", "state", "metadata", "(", ")", "customs", "(", ")", ";", "immutable", "open", "map", "<", "string", ",", "metadata", "custom", ">", "previous", "customs", "=", "previous", "state", "metadata", "(", ")", "customs", "(", ")", ";", "if", "(", "current", "customs", "equals", "(", "previous", "customs", ")", "=", "=", "false", ")", "{", "for", "(", "object", "object", "cursor", "<", "string", ",", "metadata", "custom", ">", "current", "custom", "metadata", ":", "current", "customs", ")", "{", "/", "/", "new", "custom", "md", "added", "or", "existing", "custom", "md", "changed", "if", "(", "previous", "customs", "contains", "key", "(", "current", "custom", "metadata", "key", ")", "=", "=", "false", "|", "|", "current", "custom", "metadata", "value", "equals", "(", "previous", "customs", "get", "(", "current", "custom", "metadata", "key", ")", ")", "=", "=", "false", ")", "{", "result", "add", "(", "current", "custom", "metadata", "key", ")", ";", "}", "}", "/", "/", "existing", "custom", "md", "deleted", "for", "(", "object", "object", "cursor", "<", "string", ",", "metadata", "custom", ">", "previous", "custom", "metadata", ":", "previous", "customs", ")", "{", "if", "(", "current", "customs", "contains", "key", "(", "previous", "custom", "metadata", "key", ")", "=", "=", "false", ")", "{", "result", "add", "(", "previous", "custom", "metadata", "key", ")", ";", "}", "}", "}", "return", "result", ";", "}" ]
[ "remove", "the", "cache", "by", "key" ]
[ "public", "static", "boolean", "remove", "(", "@", "non", "null", "final", "string", "key", ",", "@", "non", "null", "final", "cache", "disk", "utils", "cache", "disk", "utils", ")", "{", "return", "cache", "disk", "utils", "remove", "(", "key", ")", ";", "}" ]
[ "returns", "the", "value", "of", "the", "version", "field", ",", "as", "defined", "in", "the", "protocol", "specification" ]
[ "public", "byte", "byte", "value", "(", ")", "{", "return", "b", ";", "}" ]
[ "can", "the", "administrator", "create", "this", "type", "of", "nodes", "from", "ui", "?", "return", "false", "if", "it", "only", "makes", "sense", "for", "programs", "to", "create", "it", ",", "not", "through", "the", "\"", "new", "node", "\"", "ui" ]
[ "public", "boolean", "is", "instantiable", "(", ")", "{", "return", "true", ";", "}" ]
[ "return", "the", "files", "'", "path", "in", "zip", "file" ]
[ "public", "static", "list", "<", "string", ">", "get", "files", "path", "(", "final", "file", "zip", "file", ")", "throws", "i", "o", "exception", "{", "if", "(", "zip", "file", "=", "=", "null", ")", "return", "null", ";", "list", "<", "string", ">", "paths", "=", "new", "array", "list", "<", ">", "(", ")", ";", "zip", "file", "zip", "=", "new", "zip", "file", "(", "zip", "file", ")", ";", "enumeration", "<", "?", ">", "entries", "=", "zip", "entries", "(", ")", ";", "while", "(", "entries", "has", "more", "elements", "(", ")", ")", "{", "string", "entry", "name", "=", "(", "(", "zip", "entry", ")", "entries", "next", "element", "(", ")", ")", "get", "name", "(", ")", ";", "if", "(", "entry", "name", "contains", "(", "\"", "/", "\"", ")", ")", "{", "system", "out", "println", "(", "\"", "entry", "name", ":", "\"", "+", "entry", "name", "+", "\"", "is", "dangerous", "!", "\"", ")", ";", "paths", "add", "(", "entry", "name", ")", ";", "}", "else", "{", "paths", "add", "(", "entry", "name", ")", ";", "}", "}", "zip", "close", "(", ")", ";", "return", "paths", ";", "}" ]
[ "get", "prefix", "integer" ]
[ "public", "integer", "get", "prefix", "integer", "(", ")", "{", "return", "prefix", "integer", ";", "}" ]
[ "if", "this", "is", "a", "compiled", "xml", "file", ",", "this", "is", "the", "root", "node", "<", "code", ">", "optional", "aapt", "pb", "xml", "node", "xml", "root", "=", "5", ";", "<", "code", ">" ]
[ "private", "void", "set", "xml", "root", "(", "com", "android", "aapt", "resources", "xml", "node", "value", ")", "{", "if", "(", "value", "=", "=", "null", ")", "{", "throw", "new", "null", "pointer", "exception", "(", ")", ";", "}", "xml", "root", "=", "value", ";", "bit", "field", "0", "|", "=", "0x", "0", "0", "0", "0", "0", "0", "0", "8", ";", "}" ]
[ "return", "the", "group", "id", "that", "failed", "authorization", "may", "be", "null", "if", "it", "is", "not", "known", "in", "the", "context", "the", "exception", "was", "raised", "in" ]
[ "public", "string", "group", "id", "(", ")", "{", "return", "group", "id", ";", "}" ]
[ "grow", "the", "internal", "buffer", "size" ]
[ "public", "synchronized", "void", "grow", "(", "int", "additional", "capacity", ")", "{", "assert", "is", "true", "(", "additional", "capacity", ">", "=", "0", ",", "\"", "additional", "capacity", "must", "be", "0", "or", "higher", "\"", ")", ";", "if", "(", "this", "count", "+", "additional", "capacity", ">", "this", "buf", "length", ")", "{", "int", "new", "capacity", "=", "math", "max", "(", "this", "buf", "length", "*", "2", ",", "this", "count", "+", "additional", "capacity", ")", ";", "resize", "(", "new", "capacity", ")", ";", "}", "}" ]
[ "get", "the", "value", "of", "an", "option", ",", "or", "the", "default", "if", "the", "option", "is", "unsetempty" ]
[ "private", "int", "get", "opt", "value", "(", "string", "option", ",", "int", "def", "val", ")", "{", "command", "format", "command", "=", "get", "command", "format", "(", ")", ";", "string", "value", "=", "command", "get", "opt", "value", "(", "option", ")", ";", "if", "(", "value", "!", "=", "null", "&", "&", "!", "value", "is", "empty", "(", ")", ")", "{", "try", "{", "return", "integer", "parse", "int", "(", "value", ")", ";", "}", "catch", "(", "number", "format", "exception", "e", ")", "{", "throw", "new", "exit", "util", "exit", "exception", "(", "exit", "usage", ",", "string", "format", "(", "\"", "argument", "for", "%", "s", "is", "not", "a", "number", ":", "%", "s", "\"", ",", "option", ",", "value", ")", ")", ";", "}", "}", "else", "{", "return", "def", "val", ";", "}", "}" ]
[ "makes", "any", "text", "output", "to", "the", "terminal", "appear", "in", "bold" ]
[ "public", "void", "text", "bold", "(", ")", "throws", "i", "o", "exception", "{", "write", "escape", "sequence", "(", "text", "bold", ",", "set", "graphics", ")", ";", "}" ]
[ "returns", "the", "lowest", "value", "in", "the", "dataset", "the", "count", "must", "be", "non", "-", "zero", "<", "h", "3", ">", "non", "-", "finite", "values", "<", "h", "3", ">", "if", "the", "dataset", "contains", "{", "@", "link", "double", "#", "na", "n", "}", "then", "the", "result", "is", "{", "@", "link", "double", "#", "na", "n", "}", "if", "it", "contains", "{", "@", "link", "double", "#", "negative", "infinity", "}", "and", "not", "{", "@", "link", "double", "#", "na", "n", "}", "then", "the", "result", "is", "{", "@", "link", "double", "#", "negative", "infinity", "}", "if", "it", "contains", "{", "@", "link", "double", "#", "positive", "infinity", "}", "and", "finite", "values", "only", "then", "the", "result", "is", "the", "lowest", "finite", "value", "if", "it", "contains", "{", "@", "link", "double", "#", "positive", "infinity", "}", "only", "then", "the", "result", "is", "{", "@", "link", "double", "#", "positive", "infinity", "}" ]
[ "public", "double", "min", "(", ")", "{", "check", "state", "(", "count", "!", "=", "0", ")", ";", "return", "min", ";", "}" ]
[ "returns", "human", "-", "friendly", "help", "for", "the", "generator", "provide", "the", "consumer", "with", "help", "tips", ",", "parameters", "here" ]
[ "public", "string", "get", "help", "(", ")", "{", "return", "\"", "generates", "a", "c", "+", "+", "api", "client", "with", "c", "+", "+", "rest", "sdk", "(", "https", ":", "/", "/", "github", "com", "/", "microsoft", "/", "cpprestsdk", ")", "\"", ";", "}" ]
[ "test", "to", "string", "address", "2" ]
[ "public", "void", "test", "to", "string", "address", "2", "(", ")", "{", "assert", "that", "(", "net", "util", "to", "string", "address", "(", "ipv", "4", ")", ")", "is", "equal", "to", "(", "ipv", "4", "get", "address", "(", ")", "get", "host", "address", "(", ")", "+", "\"", ":", "\"", "+", "ipv", "4", "get", "port", "(", ")", ")", ";", "assert", "that", "(", "net", "util", "to", "string", "address", "(", "ipv", "6", ")", ")", "is", "equal", "to", "(", "ipv", "6", "get", "address", "(", ")", "get", "host", "address", "(", ")", "+", "\"", ":", "\"", "+", "ipv", "6", "get", "port", "(", ")", ")", ";", "}" ]
[ "called", "after", "the", "selection", "changes", "the", "default", "implementation", "does", "nothing" ]
[ "protected", "void", "changed", "(", ")", "{", "}" ]
[ "is", "the", "request", "authenticated", "?" ]
[ "private", "static", "boolean", "is", "request", "authenticated", "(", "final", "profile", "manager", "manager", ")", "{", "val", "opt", "=", "manager", "get", "(", "true", ")", ";", "return", "opt", "is", "present", "(", ")", ";", "}" ]
[ "verify", "ssl", "handshake", "error", "when", "untrusted", "server", "certificate", "is", "used" ]
[ "public", "void", "test", "ssl", "handshake", "error", "(", ")", "throws", "exception", "{", "netty", "protocol", "protocol", "=", "new", "no", "op", "protocol", "(", ")", ";", "configuration", "config", "=", "create", "ssl", "config", "(", ")", ";", "/", "/", "use", "a", "server", "certificate", "which", "is", "not", "present", "in", "the", "truststore", "config", "set", "string", "(", "security", "options", "ssl", "internal", "keystore", ",", "\"", "src", "/", "test", "/", "resources", "/", "untrusted", "keystore", "\"", ")", ";", "netty", "config", "netty", "config", "=", "create", "netty", "config", "(", "config", ")", ";", "netty", "test", "util", "netty", "server", "and", "client", "server", "and", "client", "=", "netty", "test", "util", "init", "server", "and", "client", "(", "protocol", ",", "netty", "config", ")", ";", "channel", "ch", "=", "netty", "test", "util", "connect", "(", "server", "and", "client", ")", ";", "ch", "pipeline", "(", ")", "add", "last", "(", "new", "string", "decoder", "(", ")", ")", "add", "last", "(", "new", "string", "encoder", "(", ")", ")", ";", "/", "/", "attempting", "to", "write", "data", "over", "ssl", "should", "fail", "assert", "false", "(", "ch", "write", "and", "flush", "(", "\"", "test", "\"", ")", "await", "(", ")", "is", "success", "(", ")", ")", ";", "netty", "test", "util", "shutdown", "(", "server", "and", "client", ")", ";", "}" ]
[ "returns", "a", "{", "@", "link", "client", "interceptor", "}", "with", "default", "tracing", "implementation" ]
[ "public", "static", "client", "interceptor", "get", "client", "interceptor", "(", ")", "{", "census", "tracing", "module", "census", "tracing", "=", "new", "census", "tracing", "module", "(", "tracing", "get", "tracer", "(", ")", ",", "tracing", "get", "propagation", "component", "(", ")", "get", "binary", "format", "(", ")", ")", ";", "return", "census", "tracing", "get", "client", "interceptor", "(", ")", ";", "}" ]
[ "translates", "a", "key", "-", "group", "id", "to", "the", "internal", "array", "offset" ]
[ "private", "int", "index", "to", "offset", "(", "int", "index", ")", "{", "return", "index", "-", "key", "group", "offset", ";", "}" ]
[ "returns", "{", "@", "code", "true", "}", "if", "a", "header", "with", "the", "name", "and", "value", "exists" ]
[ "boolean", "contains", "double", "(", "k", "name", ",", "double", "value", ")", ";" ]
[ "enters", "a", "new", "scope", "by", "appending", "any", "necessary", "whitespace", "and", "the", "given", "bracket" ]
[ "private", "json", "writer", "open", "(", "int", "empty", ",", "char", "open", "bracket", ")", "throws", "i", "o", "exception", "{", "before", "value", "(", ")", ";", "push", "(", "empty", ")", ";", "out", "write", "(", "open", "bracket", ")", ";", "return", "this", ";", "}" ]
[ "this", "test", "only", "fails", "eventually" ]
[ "public", "void", "discarding", "triggering", "checkpoint", "will", "execute", "next", "checkpoint", "request", "(", ")", "throws", "exception", "{", "final", "execution", "vertex", "execution", "vertex", "=", "mock", "execution", "vertex", "(", "new", "execution", "attempt", "i", "d", "(", ")", ")", ";", "final", "scheduled", "executor", "service", "scheduled", "executor", "service", "=", "executors", "new", "single", "thread", "scheduled", "executor", "(", ")", ";", "final", "checkpoint", "coordinator", "checkpoint", "coordinator", "=", "new", "checkpoint", "coordinator", "testing", "utils", "checkpoint", "coordinator", "builder", "(", ")", "set", "tasks", "(", "new", "execution", "vertex", "[", "]", "{", "execution", "vertex", "}", ")", "set", "timer", "(", "new", "scheduled", "executor", "service", "adapter", "(", "scheduled", "executor", "service", ")", ")", "set", "checkpoint", "coordinator", "configuration", "(", "checkpoint", "coordinator", "configuration", "builder", "(", ")", "build", "(", ")", ")", "build", "(", ")", ";", "final", "completable", "future", "<", "string", ">", "master", "hook", "checkpoint", "future", "=", "new", "completable", "future", "<", ">", "(", ")", ";", "final", "one", "shot", "latch", "trigger", "checkpoint", "latch", "=", "new", "one", "shot", "latch", "(", ")", ";", "checkpoint", "coordinator", "add", "master", "hook", "(", "new", "testing", "master", "hook", "(", "master", "hook", "checkpoint", "future", ",", "trigger", "checkpoint", "latch", ")", ")", ";", "try", "{", "checkpoint", "coordinator", "trigger", "checkpoint", "(", "false", ")", ";", "final", "completable", "future", "<", "completed", "checkpoint", ">", "second", "checkpoint", "=", "checkpoint", "coordinator", "trigger", "checkpoint", "(", "false", ")", ";", "trigger", "checkpoint", "latch", "await", "(", ")", ";", "master", "hook", "checkpoint", "future", "complete", "(", "\"", "completed", "\"", ")", ";", "/", "/", "discard", "triggering", "checkpoint", "checkpoint", "coordinator", "abort", "pending", "checkpoints", "(", "new", "checkpoint", "exception", "(", "checkpoint", "failure", "reason", "checkpoint", "declined", ")", ")", ";", "try", "{", "/", "/", "verify", "that", "the", "second", "checkpoint", "request", "will", "be", "executed", "and", "eventually", "times", "/", "/", "out", "second", "checkpoint", "get", "(", ")", ";", "fail", "(", "\"", "expected", "the", "second", "checkpoint", "to", "fail", "\"", ")", ";", "}", "catch", "(", "execution", "exception", "ee", ")", "{", "assert", "that", "(", "exception", "utils", "strip", "execution", "exception", "(", "ee", ")", ",", "instance", "of", "(", "checkpoint", "exception", "class", ")", ")", ";", "}", "}", "finally", "{", "checkpoint", "coordinator", "shutdown", "(", ")", ";", "executor", "utils", "graceful", "shutdown", "(", "10l", ",", "time", "unit", "seconds", ",", "scheduled", "executor", "service", ")", ";", "}", "}" ]
[ "translate", "a", "string", "representation", "of", "an", "ordinal", "number", "to", "the", "appropriate", "numeric", "value", "<", "br", ">", "for", "example", ",", "<", "tt", ">", "\"", "1st", "\"", "<", "tt", ">", "would", "return", "<", "tt", ">", "1", "<", "tt", ">", ",", "<", "tt", ">", "\"", "2", "3rd", "\"", "<", "tt", ">", "would", "return", "<", "tt", ">", "23", "<", "tt", ">", ",", "etc" ]
[ "private", "static", "final", "int", "get", "ordinal", "number", "(", "string", "str", ")", "{", "final", "int", "len", "=", "(", "str", "=", "=", "null", "?", "0", ":", "str", "length", "(", ")", ")", ";", "if", "(", "len", ">", "=", "3", ")", "{", "string", "suffix", "=", "str", "substring", "(", "len", "-", "2", ")", ";", "if", "(", "suffix", "equals", "ignore", "case", "(", "\"", "st", "\"", ")", "|", "|", "suffix", "equals", "ignore", "case", "(", "\"", "nd", "\"", ")", "|", "|", "suffix", "equals", "ignore", "case", "(", "\"", "rd", "\"", ")", "|", "|", "suffix", "equals", "ignore", "case", "(", "\"", "th", "\"", ")", ")", "{", "try", "{", "return", "integer", "parse", "int", "(", "str", "substring", "(", "0", ",", "len", "-", "2", ")", ")", ";", "}", "catch", "(", "number", "format", "exception", "nfe", ")", "{", "/", "/", "fall", "through", "if", "number", "was", "not", "parsed", "}", "}", "}", "return", "unset", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "dalv", "insn", "with", "register", "offset", "(", "int", "delta", ")", "{", "return", "with", "registers", "(", "get", "registers", "(", ")", "with", "offset", "(", "delta", ")", ")", ";", "}" ]
[ "set", "a", "custom", "base", "path", "for", "the", "target", "service", ",", "for", "example", "'", "v", "2", "'" ]
[ "public", "api", "client", "set", "base", "path", "(", "string", "base", "path", ")", "{", "this", "base", "path", "=", "base", "path", ";", "return", "this", ";", "}" ]
[ "refreshes", "the", "displayed", "diff", "details", "for", "the", "indicated", "program", "location", "address" ]
[ "private", "void", "do", "refresh", "details", "(", "program", "location", "p", "1", "location", ")", "{", "if", "(", "p", "1", "location", "=", "=", "null", ")", "{", "return", ";", "}", "/", "/", "do", "nothing", "if", "not", "visible", "if", "(", "!", "is", "displayed", ")", "{", "return", ";", "}", "program", "p", "1", "=", "p", "1", "location", "get", "program", "(", ")", ";", "if", "(", "p", "1", "!", "=", "plugin", "get", "first", "program", "(", ")", "&", "&", "p", "1", "!", "=", "plugin", "get", "second", "program", "(", ")", ")", "{", "return", ";", "/", "/", "if", "this", "location", "isn", "'", "t", "for", "our", "diff", "then", "ignore", "it", "may", "be", "switching", "program", "tabs", "}", "if", "(", "p", "1", "details", "location", "!", "=", "p", "1", "location", ")", "{", "p", "1", "details", "location", "=", "p", "1", "location", ";", "}", "address", "set", "view", "new", "addr", "set", "=", "get", "details", "address", "set", "(", "p", "1", "details", "location", ")", ";", "if", "(", "new", "addr", "set", "=", "=", "null", ")", "{", "set", "document", "to", "error", "message", "(", "\"", "must", "have", "a", "second", "program", "open", "to", "determine", "diff", "details", "\"", ")", ";", "return", ";", "}", "if", "(", "!", "new", "addr", "set", "equals", "(", "details", "addr", "set", ")", ")", "{", "details", "addr", "set", "=", "new", "addr", "set", ";", "}", "address", "p", "1", "address", "=", "p", "1", "details", "location", "get", "address", "(", ")", ";", "try", "{", "if", "(", "filter", "diffs", ")", "{", "get", "filtered", "diff", "details", "(", "p", "1", "address", ")", ";", "}", "else", "{", "get", "diff", "details", "(", "p", "1", "address", ")", ";", "}", "}", "catch", "(", "concurrent", "modification", "exception", "e", ")", "{", "set", "document", "to", "error", "message", "(", "\"", "failed", "to", "determine", "diff", "details", "due", "to", "concurrent", "program", "changes", "\\", "n", "\"", "+", "\"", "this", "may", "be", "caused", "by", "background", "analysis", "activity", "\\", "n", "\"", "+", "\"", "*", "*", "*", "press", "the", "refresh", "button", "to", "update", "*", "*", "*", "\"", ")", ";", "/", "/", "the", "program", "is", "being", "modified", "while", "this", "is", "trying", "to", "get", "the", "details", "/", "/", "if", "we", "want", "to", "automatically", "try", "again", ",", "this", "would", "need", "to", "re", "-", "issue", "the", "update", "/", "/", "by", "calling", "update", "manager", "update", "later", "(", ")", "here", "}", "}" ]
[ "get", "array", "of", "string" ]
[ "public", "list", "<", "string", ">", "get", "array", "of", "string", "(", ")", "{", "return", "array", "of", "string", ";", "}" ]
[ "streams", "lines", "from", "a", "{", "@", "link", "file", "}", ",", "stopping", "when", "our", "callback", "returns", "false", ",", "or", "we", "have", "read", "all", "of", "the", "lines" ]
[ "static", "<", "t", ">", "t", "read", "lines", "(", "file", "file", ",", "charset", "charset", ",", "line", "processor", "<", "t", ">", "callback", ")", "throws", "i", "o", "exception", "{", "return", "as", "char", "source", "(", "file", ",", "charset", ")", "read", "lines", "(", "callback", ")", ";", "}" ]
[ "creates", "an", "{", "@", "code", "atomic", "reference", "array", "}", "instance", "with", "the", "same", "length", "as", ",", "and", "all", "elements", "copied", "from", ",", "the", "given", "array" ]
[ "public", "static", "<", "e", ">", "atomic", "reference", "array", "<", "e", ">", "new", "reference", "array", "(", "e", "[", "]", "array", ")", "{", "return", "new", "atomic", "reference", "array", "<", "e", ">", "(", "array", ")", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "reads", "an", "operation", "at", "the", "given", "position", "into", "the", "given", "buffer" ]
[ "protected", "void", "read", "bytes", "(", "byte", "buffer", "buffer", ",", "long", "position", ")", "throws", "i", "o", "exception", "{", "try", "{", "if", "(", "position", ">", "=", "length", ")", "{", "throw", "new", "e", "o", "f", "exception", "(", "\"", "read", "requested", "past", "eof", "pos", "[", "\"", "+", "position", "+", "\"", "]", "end", ":", "[", "\"", "+", "length", "+", "\"", "]", ",", "generation", ":", "[", "\"", "+", "get", "generation", "(", ")", "+", "\"", "]", ",", "path", ":", "[", "\"", "+", "path", "+", "\"", "]", "\"", ")", ";", "}", "if", "(", "position", "<", "get", "first", "operation", "offset", "(", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "read", "requested", "before", "position", "of", "first", "ops", "pos", "[", "\"", "+", "position", "+", "\"", "]", "first", "op", "on", ":", "[", "\"", "+", "get", "first", "operation", "offset", "(", ")", "+", "\"", "]", ",", "generation", ":", "[", "\"", "+", "get", "generation", "(", ")", "+", "\"", "]", ",", "path", ":", "[", "\"", "+", "path", "+", "\"", "]", "\"", ")", ";", "}", "channels", "read", "from", "file", "channel", "with", "eof", "exception", "(", "channel", ",", "position", ",", "buffer", ")", ";", "}", "catch", "(", "e", "o", "f", "exception", "e", ")", "{", "throw", "new", "translog", "corrupted", "exception", "(", "path", "to", "string", "(", ")", ",", "\"", "translog", "truncated", "\"", ",", "e", ")", ";", "}", "}" ]
[ "test", "a", "cluster", "with", "even", "distribution", ",", "then", "three", "nodes", "are", "added", "to", "the", "cluster", ",", "runs", "balancer", "with", "two", "of", "the", "nodes", "in", "the", "include", "list" ]
[ "public", "void", "test", "balancer", "with", "include", "list", "(", ")", "throws", "exception", "{", "final", "configuration", "conf", "=", "new", "hdfs", "configuration", "(", ")", ";", "init", "conf", "(", "conf", ")", ";", "set", "<", "string", ">", "include", "hosts", "=", "new", "hash", "set", "<", "string", ">", "(", ")", ";", "include", "hosts", "add", "(", "\"", "datanode", "y", "\"", ")", ";", "do", "test", "(", "conf", ",", "new", "long", "[", "]", "{", "capacity", ",", "capacity", "}", ",", "new", "string", "[", "]", "{", "rack0", ",", "rack1", "}", ",", "capacity", ",", "rack2", ",", "new", "host", "name", "based", "nodes", "(", "new", "string", "[", "]", "{", "\"", "datanode", "x", "\"", ",", "\"", "datanode", "y", "\"", ",", "\"", "datanode", "z", "\"", "}", ",", "balancer", "parameters", "default", "get", "excluded", "nodes", "(", ")", ",", "include", "hosts", ")", ",", "false", ",", "false", ")", ";", "}" ]
[ "if", "the", "field", "supports", "using", "the", "indexed", "data", "to", "speed", "up", "operations", "related", "to", "ordering", "of", "data", ",", "such", "as", "sorting", "or", "aggs", ",", "return", "a", "function", "for", "doing", "that", "if", "it", "is", "unsupported", "for", "this", "field", "type", ",", "there", "is", "no", "need", "to", "override", "this", "method" ]
[ "public", "function", "<", "byte", "[", "]", ",", "number", ">", "point", "reader", "if", "possible", "(", ")", "{", "return", "null", ";", "}" ]
[ "returns", "the", "list", "of", "symbols", "these", "may", "not", "be", "in", "the", "order", "that", "they", "were", "seen" ]
[ "list", "<", "abstract", "ms", "symbol", ">", "get", "symbols", "(", ")", "{", "return", "new", "array", "list", "<", ">", "(", "symbols", "by", "offset", "values", "(", ")", ")", ";", "}" ]
[ "get", "my", "boolean" ]
[ "public", "boolean", "get", "my", "boolean", "(", ")", "{", "return", "my", "boolean", ";", "}" ]
[ "gets", "the", "preferred", "resources", "for", "this", "contract", "instance", "the", "preferred", "resources", "denote", "how", "many", "resources", "will", "be", "needed", "in", "the", "maximum", "for", "the", "user", "function", "during", "the", "execution" ]
[ "public", "resource", "spec", "get", "preferred", "resources", "(", ")", "{", "return", "this", "preferred", "resources", ";", "}" ]
[ "create", "an", "http", "delete", "builder", "with", "the", "given", "url" ]
[ "public", "static", "headers", "builder", "<", "?", ">", "delete", "(", "uri", "url", ")", "{", "return", "method", "(", "http", "method", "delete", ",", "url", ")", ";", "}" ]
[ "called", "on", "a", "background", "thread", "so", "the", "{", "@", "link", "resource", "}", "can", "do", "some", "eager", "initialization" ]
[ "void", "initialize", "(", ")", ";" ]
[ "return", "the", "configured", "{", "@", "link", "#", "set", "metadata", "extractor", "metadata", "extractor", "}" ]
[ "public", "metadata", "extractor", "get", "metadata", "extractor", "(", ")", "{", "return", "this", "strategies", "metadata", "extractor", "(", ")", ";", "}" ]
[ "for", "local", "logs", "we", "can", "only", "check", "the", "redirect", "to", "the", "appropriate", "node" ]
[ "public", "void", "test", "get", "container", "log", "file", "for", "running", "container", "(", ")", "throws", "exception", "{", "web", "resource", "r", "=", "resource", "(", ")", ";", "uri", "request", "u", "r", "i", "=", "r", "path", "(", "\"", "ws", "\"", ")", "path", "(", "\"", "v", "1", "\"", ")", "path", "(", "\"", "history", "\"", ")", "path", "(", "\"", "containerlogs", "\"", ")", "path", "(", "container", "2", "2", "2", "to", "string", "(", ")", ")", "path", "(", "file", "name", ")", "get", "u", "r", "i", "(", ")", ";", "string", "redirect", "u", "r", "l", "=", "get", "redirect", "u", "r", "l", "(", "request", "u", "r", "i", "to", "string", "(", ")", ")", ";", "assert", "that", "(", "redirect", "u", "r", "l", ")", "is", "not", "null", "(", ")", ";", "assert", "that", "(", "redirect", "u", "r", "l", ")", "contains", "(", "nm", "webaddress", "1", ",", "\"", "ws", "/", "v", "1", "/", "node", "/", "containers", "\"", ",", "\"", "/", "logs", "/", "\"", "+", "file", "name", ",", "container", "2", "2", "2", "to", "string", "(", ")", ")", ";", "/", "/", "if", "we", "specify", "nm", "id", ",", "we", "would", "re", "-", "direct", "the", "request", "/", "/", "to", "this", "nm", "'", "s", "web", "address", "request", "u", "r", "i", "=", "r", "path", "(", "\"", "ws", "\"", ")", "path", "(", "\"", "v", "1", "\"", ")", "path", "(", "\"", "history", "\"", ")", "path", "(", "\"", "containerlogs", "\"", ")", "path", "(", "container", "2", "2", "2", "to", "string", "(", ")", ")", "path", "(", "file", "name", ")", "query", "param", "(", "yarn", "web", "service", "params", "nm", "id", ",", "nm", "id", "2", "to", "string", "(", ")", ")", "get", "u", "r", "i", "(", ")", ";", "redirect", "u", "r", "l", "=", "get", "redirect", "u", "r", "l", "(", "request", "u", "r", "i", "to", "string", "(", ")", ")", ";", "assert", "that", "(", "redirect", "u", "r", "l", ")", "is", "not", "null", "(", ")", ";", "assert", "that", "(", "redirect", "u", "r", "l", ")", "contains", "(", "nm", "webaddress", "2", ",", "\"", "ws", "/", "v", "1", "/", "node", "/", "containers", "\"", ",", "\"", "/", "logs", "/", "\"", "+", "file", "name", ",", "container", "2", "2", "2", "to", "string", "(", ")", ")", ";", "/", "/", "if", "this", "is", "the", "redirect", "request", ",", "we", "would", "not", "re", "-", "direct", "the", "request", "/", "/", "back", "and", "get", "the", "aggregated", "logs", "client", "response", "response", "=", "r", "path", "(", "\"", "ws", "\"", ")", "path", "(", "\"", "v", "1", "\"", ")", "path", "(", "\"", "history", "\"", ")", "path", "(", "\"", "containerlogs", "\"", ")", "path", "(", "container", "2", "2", "3", "to", "string", "(", ")", ")", "path", "(", "file", "name", ")", "query", "param", "(", "yarn", "web", "service", "params", "redirected", "from", "node", ",", "\"", "true", "\"", ")", "accept", "(", "media", "type", "text", "plain", ")", "get", "(", "client", "response", "class", ")", ";", "string", "response", "text", "=", "response", "get", "entity", "(", "string", "class", ")", ";", "assert", "that", "(", "response", "text", ")", "is", "not", "null", "(", ")", ";", "assert", "that", "(", "response", "text", ")", "contains", "(", "\"", "log", "aggregation", "type", ":", "\"", "+", "container", "log", "aggregation", "type", "aggregated", ",", "\"", "hello", "-", "\"", "+", "container", "2", "2", "3", ")", ";", "}" ]
[ "list", "entries", "in", "a", "filesystem", "directory" ]
[ "public", "string", "list", "f", "s", "dir", "(", "path", "path", ")", "throws", "i", "o", "exception", "{", "file", "status", "[", "]", "stats", "=", "file", "system", "list", "status", "(", "path", ")", ";", "string", "builder", "builder", "=", "new", "string", "builder", "(", ")", ";", "for", "(", "file", "status", "stat", ":", "stats", ")", "{", "builder", "append", "(", "stat", "get", "path", "(", ")", "to", "string", "(", ")", ")", "append", "(", "\"", "\\", "t", "\"", ")", "append", "(", "stat", "get", "len", "(", ")", ")", "append", "(", "\"", "\\", "n", "\"", ")", ";", "}", "return", "builder", "to", "string", "(", ")", ";", "}" ]
[ "model", "tests", "for", "class", "model" ]
[ "public", "void", "test", "class", "model", "(", ")", "{", "/", "/", "todo", ":", "test", "class", "model", "}" ]
[ "gets", "the", "format", "and", "allowed", "cp", "types", "of", "the", "given", "opcode" ]
[ "public", "static", "int", "op", "info", "(", "int", "opcode", ")", "{", "return", "opcode", "info", "[", "opcode", "]", ";", "}" ]
[ "query", "{", "@", "link", "service", "relation", "server", "side", "metrics", "}", "globally", ",", "without", "given", "service", "ids" ]
[ "list", "<", "call", "call", "detail", ">", "load", "service", "relations", "detected", "at", "server", "side", "(", "long", "start", "t", "b", ",", "long", "end", "t", "b", ")", "throws", "i", "o", "exception", ";" ]
[ "returns", "the", "path", "of", "the", "symlink", "target" ]
[ "path", "fragment", "get", "target", "in", "symlink", "tree", "(", "boolean", "follow", "symlinks", ")", "throws", "dangling", "symlink", "exception", ";" ]
[ "disposes", "the", "given", "process", "and", "related", "streams", "from", "a", "background", "thread", "this", "is", "necessary", "due", "to", "a", "low", "-", "probability", "deadlock", "that", "occurs", "in", "the", "jvm" ]
[ "public", "static", "void", "dispose", "(", "process", "process", ",", "output", "stream", "ouput", "stream", ",", "input", "stream", "input", "stream", ")", "{", "runtime", "process", "disposable", "disposable", "=", "new", "runtime", "process", "disposable", "(", "process", ",", "ouput", "stream", ",", "input", "stream", ")", ";", "queue", "add", "(", "disposable", ")", ";", "}" ]
[ "tests", "maximum", "opportunistic", "container", "allocation", "per", "am", "heartbeat", "when", "limit", "is", "set", "to", "-", "1" ]
[ "public", "void", "test", "max", "allocations", "per", "a", "m", "heartbeat", "with", "no", "limit", "(", ")", "throws", "exception", "{", "allocator", "set", "max", "allocations", "per", "a", "m", "heartbeat", "(", "-", "1", ")", ";", "list", "<", "resource", "request", ">", "reqs", "=", "new", "array", "list", "<", ">", "(", ")", ";", "final", "int", "num", "containers", "=", "20", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num", "containers", ";", "i", "+", "+", ")", "{", "reqs", "add", "(", "create", "resource", "request", "(", "i", "+", "1", ",", "\"", "h", "1", "\"", ",", "1", ")", ")", ";", "}", "application", "attempt", "id", "app", "att", "id", "=", "application", "attempt", "id", "new", "instance", "(", "application", "id", "new", "instance", "(", "0l", ",", "1", ")", ",", "1", ")", ";", "allocator", "set", "node", "queue", "load", "monitor", "(", "create", "node", "queue", "load", "monitor", "(", "3", ",", "2", ",", "500", ")", ")", ";", "list", "<", "container", ">", "containers", "=", "allocator", "allocate", "containers", "(", "empty", "blacklist", "request", ",", "reqs", ",", "app", "att", "id", ",", "opp", "cntxt", ",", "1l", ",", "\"", "user", "\"", ")", ";", "/", "/", "all", "containers", "should", "be", "allocated", "in", "single", "heartbeat", "assert", "equals", "(", "num", "containers", ",", "containers", "size", "(", ")", ")", ";", "}" ]
[ "put", "faketest", "-", "query", "-", "paramters", "to", "test", "the", "collection", "format", "in", "query", "parameters" ]
[ "default", "response", "entity", "<", "void", ">", "test", "query", "parameter", "collection", "format", "(", "list", "<", "string", ">", "pipe", ",", "list", "<", "string", ">", "ioutil", ",", "list", "<", "string", ">", "http", ",", "list", "<", "string", ">", "url", ",", "list", "<", "string", ">", "context", ")", "{", "return", "new", "response", "entity", "<", ">", "(", "http", "status", "not", "implemented", ")", ";", "}" ]
[ "test", "set", "resource", "sets", "to", "null", "test", "get", "resource", "sets" ]
[ "public", "void", "test", "resource", "sets", "null", "(", ")", "{", "rpc", "context", "set", "resource", "sets", "(", "null", ")", ";", "assertions", "assert", "null", "(", "rpc", "context", "get", "resource", "sets", "(", ")", ")", ";", "}" ]
[ "notify", "this", "app", "that", "preemption", "has", "been", "triggered", "to", "make", "room", "for", "outstanding", "demand", "the", "app", "should", "not", "be", "considered", "starved", "until", "after", "the", "specified", "delay" ]
[ "void", "preemption", "triggered", "(", "long", "delay", "before", "next", "starvation", "check", ")", "{", "next", "starvation", "check", "=", "scheduler", "get", "clock", "(", ")", "get", "time", "(", ")", "+", "delay", "before", "next", "starvation", "check", ";", "}" ]
[ "called", "when", "am", "heartbeats", "these", "containers", "were", "recovered", "by", "the", "rm", "after", "the", "am", "had", "registered", "they", "are", "reported", "to", "the", "am", "in", "the", "<", "code", ">", "allocate", "response", "#", "containers", "from", "previous", "attempts", "<", "code", ">" ]
[ "public", "list", "<", "container", ">", "pull", "previous", "attempt", "containers", "(", ")", "{", "write", "lock", "lock", "(", ")", ";", "try", "{", "if", "(", "recovered", "previous", "attempt", "containers", "is", "empty", "(", ")", ")", "{", "return", "null", ";", "}", "list", "<", "container", ">", "return", "container", "list", "=", "new", "array", "list", "<", ">", "(", "recovered", "previous", "attempt", "containers", ")", ";", "recovered", "previous", "attempt", "containers", "clear", "(", ")", ";", "update", "n", "m", "tokens", "(", "return", "container", "list", ")", ";", "return", "return", "container", "list", ";", "}", "finally", "{", "write", "lock", "unlock", "(", ")", ";", "}", "}" ]
[ "starts", "transport", "this", "method", "may", "only", "be", "called", "once", "implementations", "must", "not", "call", "{", "@", "code", "listener", "}", "from", "within", "{", "@", "link", "#", "start", "}", ";", "implementations", "are", "expected", "to", "notify", "listener", "on", "a", "separate", "thread", "or", "when", "the", "returned", "{", "@", "link", "runnable", "}", "is", "run", "this", "method", "and", "the", "returned", "{", "@", "code", "runnable", "}", "should", "not", "throw", "any", "exceptions" ]
[ "runnable", "start", "(", "listener", "listener", ")", ";" ]
[ "generate", "the", "fully", "qualified", "method", "name", "this", "matches", "the", "name" ]
[ "public", "static", "string", "generate", "full", "method", "name", "(", "string", "full", "service", "name", ",", "string", "method", "name", ")", "{", "return", "check", "not", "null", "(", "full", "service", "name", ",", "\"", "full", "service", "name", "\"", ")", "+", "\"", "/", "\"", "+", "check", "not", "null", "(", "method", "name", ",", "\"", "method", "name", "\"", ")", ";", "}" ]
[ "sets", "the", "focused", "item", "to", "the", "given", "column", "column", "focus", "is", "only", "applicable", "when", "cell", "selection", "is", "enabled" ]
[ "public", "void", "set", "focus", "column", "(", "int", "col", ")", "{", "check", "widget", "(", ")", ";", "grid", "column", "column", "=", "get", "column", "(", "col", ")", ";", "if", "(", "column", "=", "=", "null", "|", "|", "column", "get", "grid", "(", ")", "!", "=", "this", ")", "{", "swt", "error", "(", "swt", "error", "invalid", "argument", ")", ";", "return", ";", "}", "focus", "column", "=", "column", ";", "}" ]
[ "finds", "pets", "by", "status", "multiple", "status", "values", "can", "be", "provided", "with", "comma", "separated", "strings" ]
[ "public", "void", "find", "pets", "by", "status", "test", "(", "test", "context", "test", "context", ")", "{", "async", "async", "=", "test", "context", "async", "(", ")", ";", "list", "<", "string", ">", "status", "=", "null", ";", "api", "find", "pets", "by", "status", "(", "status", ",", "result", "-", ">", "{", "/", "/", "todo", ":", "test", "validations", "async", "complete", "(", ")", ";", "}", ")", ";", "}" ]
[ "update", "an", "existing", "pet" ]
[ "public", "void", "update", "pet", "test", "(", ")", "throws", "api", "exception", "{", "pet", "pet", "=", "null", ";", "api", "update", "pet", "(", "pet", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "see", "https", ":", "activiti", "atlassian", "netbrowse", "a", "c", "t", "-", "2089" ]
[ "public", "void", "test", "due", "date", "sorting", "with", "nulls", "(", ")", "{", "date", "now", "=", "process", "engine", "configuration", "get", "clock", "(", ")", "get", "current", "time", "(", ")", ";", "/", "/", "4", "tasks", "with", "a", "due", "date", "create", "task", "(", "\"", "task", "0", "\"", ",", "new", "date", "(", "now", "get", "time", "(", ")", "+", "(", "4l", "*", "7l", "*", "24l", "*", "60l", "*", "60l", "*", "1000l", ")", ")", ")", ";", "/", "/", "4", "weeks", "in", "future", "create", "task", "(", "\"", "task", "1", "\"", ",", "new", "date", "(", "now", "get", "time", "(", ")", "+", "(", "2", "*", "24l", "*", "60l", "*", "60l", "*", "1000l", ")", ")", ")", ";", "/", "/", "2", "days", "in", "future", "create", "task", "(", "\"", "task", "2", "\"", ",", "new", "date", "(", "now", "get", "time", "(", ")", "+", "(", "7l", "*", "24l", "*", "60l", "*", "60l", "*", "1000l", ")", ")", ")", ";", "/", "/", "1", "week", "in", "future", "create", "task", "(", "\"", "task", "3", "\"", ",", "new", "date", "(", "now", "get", "time", "(", ")", "+", "(", "24l", "*", "60l", "*", "60l", "*", "1000l", ")", ")", ")", ";", "/", "/", "1", "day", "in", "future", "/", "/", "2", "tasks", "without", "a", "due", "date", "create", "task", "(", "\"", "task", "4", "\"", ",", "null", ")", ";", "create", "task", "(", "\"", "task", "5", "\"", ",", "null", ")", ";", "assert", "that", "(", "task", "service", "create", "task", "query", "(", ")", "count", "(", ")", ")", "is", "equal", "to", "(", "6", ")", ";", "/", "/", "sorting", "on", "due", "date", "asc", "should", "put", "the", "nulls", "at", "the", "end", "list", "<", "task", ">", "tasks", "=", "task", "service", "create", "task", "query", "(", ")", "order", "by", "due", "date", "nulls", "last", "(", ")", "asc", "(", ")", "list", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "4", ";", "i", "+", "+", ")", "{", "assert", "that", "(", "tasks", "get", "(", "i", ")", "get", "due", "date", "(", ")", ")", "is", "not", "null", "(", ")", ";", "}", "assert", "that", "(", "tasks", "get", "(", "0", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "3", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "1", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "1", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "2", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "2", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "3", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "0", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "4", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "assert", "that", "(", "tasks", "get", "(", "5", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "/", "/", "the", "same", ",", "but", "now", "desc", "tasks", "=", "task", "service", "create", "task", "query", "(", ")", "order", "by", "due", "date", "nulls", "last", "(", ")", "desc", "(", ")", "list", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "4", ";", "i", "+", "+", ")", "{", "assert", "that", "(", "tasks", "get", "(", "i", ")", "get", "due", "date", "(", ")", ")", "is", "not", "null", "(", ")", ";", "}", "assert", "that", "(", "tasks", "get", "(", "0", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "0", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "1", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "2", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "2", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "1", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "3", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "3", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "4", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "assert", "that", "(", "tasks", "get", "(", "5", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "/", "/", "the", "same", "but", "now", "nulls", "first", "tasks", "=", "task", "service", "create", "task", "query", "(", ")", "order", "by", "due", "date", "nulls", "first", "(", ")", "asc", "(", ")", "list", "(", ")", ";", "assert", "that", "(", "tasks", "get", "(", "0", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "assert", "that", "(", "tasks", "get", "(", "1", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "assert", "that", "(", "tasks", "get", "(", "2", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "3", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "3", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "1", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "4", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "2", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "5", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "0", "\"", ")", ";", "/", "/", "and", "now", "desc", "tasks", "=", "task", "service", "create", "task", "query", "(", ")", "order", "by", "due", "date", "nulls", "first", "(", ")", "desc", "(", ")", "list", "(", ")", ";", "assert", "that", "(", "tasks", "get", "(", "0", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "assert", "that", "(", "tasks", "get", "(", "1", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "assert", "that", "(", "tasks", "get", "(", "2", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "0", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "3", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "2", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "4", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "1", "\"", ")", ";", "assert", "that", "(", "tasks", "get", "(", "5", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "3", "\"", ")", ";", "if", "(", "process", "engine", "configuration", "get", "history", "level", "(", ")", "is", "at", "least", "(", "history", "level", "audit", ")", ")", "{", "/", "/", "and", "now", "the", "same", ",", "but", "for", "history", "!", "list", "<", "historic", "task", "instance", ">", "historic", "tasks", "=", "history", "service", "create", "historic", "task", "instance", "query", "(", ")", "order", "by", "due", "date", "nulls", "last", "(", ")", "asc", "(", ")", "list", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "4", ";", "i", "+", "+", ")", "{", "assert", "that", "(", "historic", "tasks", "get", "(", "i", ")", "get", "due", "date", "(", ")", ")", "is", "not", "null", "(", ")", ";", "}", "assert", "that", "(", "historic", "tasks", "get", "(", "0", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "3", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "1", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "1", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "2", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "2", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "3", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "0", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "4", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "5", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "/", "/", "the", "same", ",", "but", "now", "desc", "historic", "tasks", "=", "history", "service", "create", "historic", "task", "instance", "query", "(", ")", "order", "by", "due", "date", "nulls", "last", "(", ")", "desc", "(", ")", "list", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "4", ";", "i", "+", "+", ")", "{", "assert", "that", "(", "historic", "tasks", "get", "(", "i", ")", "get", "due", "date", "(", ")", ")", "is", "not", "null", "(", ")", ";", "}", "assert", "that", "(", "historic", "tasks", "get", "(", "0", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "0", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "1", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "2", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "2", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "1", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "3", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "3", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "4", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "5", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "/", "/", "the", "same", "but", "now", "nulls", "first", "historic", "tasks", "=", "history", "service", "create", "historic", "task", "instance", "query", "(", ")", "order", "by", "due", "date", "nulls", "first", "(", ")", "asc", "(", ")", "list", "(", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "0", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "1", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "2", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "3", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "3", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "1", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "4", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "2", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "5", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "0", "\"", ")", ";", "/", "/", "and", "now", "desc", "historic", "tasks", "=", "history", "service", "create", "historic", "task", "instance", "query", "(", ")", "order", "by", "due", "date", "nulls", "first", "(", ")", "desc", "(", ")", "list", "(", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "0", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "1", ")", "get", "due", "date", "(", ")", ")", "is", "null", "(", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "2", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "0", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "3", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "2", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "4", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "1", "\"", ")", ";", "assert", "that", "(", "historic", "tasks", "get", "(", "5", ")", "get", "name", "(", ")", ")", "is", "equal", "to", "(", "\"", "task", "3", "\"", ")", ";", "}", "}" ]
[ "kills", "the", "soundpool", "and", "all", "other", "resources" ]
[ "public", "void", "dispose", "(", ")", "{", "if", "(", "sound", "pool", "=", "=", "null", ")", "{", "return", ";", "}", "synchronized", "(", "musics", ")", "{", "/", "/", "gah", "i", "hate", "myself", "music", "dispose", "(", ")", "removes", "the", "music", "from", "the", "list", "array", "list", "<", "android", "music", ">", "musics", "copy", "=", "new", "array", "list", "<", "android", "music", ">", "(", "musics", ")", ";", "for", "(", "android", "music", "music", ":", "musics", "copy", ")", "{", "music", "dispose", "(", ")", ";", "}", "}", "sound", "pool", "release", "(", ")", ";", "}" ]
[ "shuts", "down", "and", "clean", "up", "the", "timer", "service", "provider", "hard", "and", "immediately", "this", "does", "not", "wait", "for", "any", "timer", "to", "complete", "any", "further", "call", "to", "{", "@", "link", "#", "register", "timer", "(", "long", ",", "processing", "time", "callback", ")", "}", "will", "result", "in", "a", "hard", "exception", "this", "call", "cannot", "be", "interrupted", "and", "will", "block", "until", "the", "shutdown", "is", "completed", "or", "the", "timeout", "is", "exceeded" ]
[ "boolean", "shutdown", "service", "uninterruptible", "(", "long", "timeout", "ms", ")", ";" ]
[ "sets", "{", "@", "link", "endpoint", "#", "port", "as", "int", "(", ")", "}" ]
[ "public", "builder", "port", "(", "int", "port", ")", "{", "if", "(", "port", ">", "0xffff", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "invalid", "port", "\"", "+", "port", ")", ";", "if", "(", "port", "<", "0", ")", "port", "=", "0", ";", "this", "port", "=", "port", ";", "return", "this", ";", "}" ]
[ "test", "the", "property", "'", "class", "name", "'" ]
[ "public", "void", "class", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "class", "name", "}" ]
[ "puts", "the", "module", ",", "module", "packages", "and", "module", "main", "class", "attributes", "generated", "by", "this", "module", "writer", "in", "the", "given", "byte", "vector" ]
[ "void", "put", "attributes", "(", "final", "byte", "vector", "output", ")", "{", "/", "/", "6", "bytes", "for", "name", ",", "flags", "and", "version", ",", "and", "5", "*", "2", "bytes", "for", "counts", "int", "module", "attribute", "length", "=", "16", "+", "requires", "length", "+", "exports", "length", "+", "opens", "length", "+", "uses", "index", "length", "+", "provides", "length", ";", "output", "put", "short", "(", "symbol", "table", "add", "constant", "utf", "8", "(", "constants", "module", ")", ")", "put", "int", "(", "module", "attribute", "length", ")", "put", "short", "(", "module", "name", "index", ")", "put", "short", "(", "module", "flags", ")", "put", "short", "(", "module", "version", "index", ")", "put", "short", "(", "requires", "count", ")", "put", "byte", "array", "(", "requires", "data", ",", "0", ",", "requires", "length", ")", "put", "short", "(", "exports", "count", ")", "put", "byte", "array", "(", "exports", "data", ",", "0", ",", "exports", "length", ")", "put", "short", "(", "opens", "count", ")", "put", "byte", "array", "(", "opens", "data", ",", "0", ",", "opens", "length", ")", "put", "short", "(", "uses", "count", ")", "put", "byte", "array", "(", "uses", "index", "data", ",", "0", ",", "uses", "index", "length", ")", "put", "short", "(", "provides", "count", ")", "put", "byte", "array", "(", "provides", "data", ",", "0", ",", "provides", "length", ")", ";", "if", "(", "package", "count", ">", "0", ")", "{", "output", "put", "short", "(", "symbol", "table", "add", "constant", "utf", "8", "(", "constants", "module", "packages", ")", ")", "put", "int", "(", "2", "+", "package", "index", "length", ")", "put", "short", "(", "package", "count", ")", "put", "byte", "array", "(", "package", "index", "data", ",", "0", ",", "package", "index", "length", ")", ";", "}", "if", "(", "main", "class", "index", ">", "0", ")", "{", "output", "put", "short", "(", "symbol", "table", "add", "constant", "utf", "8", "(", "constants", "module", "main", "class", ")", ")", "put", "int", "(", "2", ")", "put", "short", "(", "main", "class", "index", ")", ";", "}", "}" ]
[ "the", "persisted", "global", "checkpoint", "for", "the", "shard" ]
[ "long", "global", "checkpoint", "(", ")", ";" ]
[ "decodes", "the", "specified", "character", "sequence", ",", "and", "returns", "the", "resulting", "{", "@", "code", "byte", "[", "]", "}", "this", "is", "the", "inverse", "operation", "to", "{", "@", "link", "#", "encode", "(", "byte", "[", "]", ")", "}" ]
[ "final", "byte", "[", "]", "decode", "checked", "(", "char", "sequence", "chars", ")", "throws", "decoding", "exception", "{", "chars", "=", "trim", "trailing", "padding", "(", "chars", ")", ";", "byte", "[", "]", "tmp", "=", "new", "byte", "[", "max", "decoded", "size", "(", "chars", "length", "(", ")", ")", "]", ";", "int", "len", "=", "decode", "to", "(", "tmp", ",", "chars", ")", ";", "return", "extract", "(", "tmp", ",", "len", ")", ";", "}" ]
[ "see", "spr", "-", "9457" ]
[ "void", "uses", "bound", "connection", "if", "available", "(", ")", "throws", "s", "q", "l", "exception", "{", "transaction", "synchronization", "manager", "init", "synchronization", "(", ")", ";", "connection", "connection", "=", "data", "source", "utils", "get", "connection", "(", "db", ")", ";", "database", "populator", "populator", "=", "mock", "(", "database", "populator", "class", ")", ";", "database", "populator", "utils", "execute", "(", "populator", ",", "db", ")", ";", "verify", "(", "populator", ")", "populate", "(", "connection", ")", ";", "}" ]
[ "creates", "{", "@", "link", "consumer", "record", "consumer", "records", "}", "with", "the", "given", "topic", "name", ",", "keys", ",", "and", "values", "the", "timestamp", "will", "be", "generated", "based", "on", "the", "constructor", "provided", "start", "time", "and", "time", "will", "auto", "advance" ]
[ "public", "list", "<", "consumer", "record", "<", "byte", "[", "]", ",", "byte", "[", "]", ">", ">", "create", "(", "final", "string", "topic", "name", ",", "final", "list", "<", "key", "value", "<", "k", ",", "v", ">", ">", "key", "values", ")", "{", "final", "list", "<", "consumer", "record", "<", "byte", "[", "]", ",", "byte", "[", "]", ">", ">", "records", "=", "new", "array", "list", "<", ">", "(", "key", "values", "size", "(", ")", ")", ";", "for", "(", "final", "key", "value", "<", "k", ",", "v", ">", "key", "value", ":", "key", "values", ")", "{", "records", "add", "(", "create", "(", "topic", "name", ",", "key", "value", "key", ",", "key", "value", "value", ")", ")", ";", "}", "return", "records", ";", "}" ]
[ "gets", "the", "byte", "array", "that", "backs", "this", "memory", "segment" ]
[ "public", "byte", "[", "]", "get", "array", "(", ")", "{", "return", "this", "memory", ";", "}" ]
[ "wraps", "the", "specified", "timeline", "in", "a", "{", "@", "link", "looping", "media", "source", "}", "and", "returns", "the", "looping", "timeline" ]
[ "private", "static", "timeline", "get", "looping", "timeline", "(", "timeline", "timeline", ",", "int", "loop", "count", ")", "throws", "i", "o", "exception", "{", "fake", "media", "source", "fake", "media", "source", "=", "new", "fake", "media", "source", "(", "timeline", ")", ";", "looping", "media", "source", "media", "source", "=", "new", "looping", "media", "source", "(", "fake", "media", "source", ",", "loop", "count", ")", ";", "media", "source", "test", "runner", "test", "runner", "=", "new", "media", "source", "test", "runner", "(", "media", "source", ",", "null", ")", ";", "try", "{", "timeline", "looping", "timeline", "=", "test", "runner", "prepare", "source", "(", ")", ";", "test", "runner", "release", "source", "(", ")", ";", "fake", "media", "source", "assert", "released", "(", ")", ";", "return", "looping", "timeline", ";", "}", "finally", "{", "test", "runner", "release", "(", ")", ";", "}", "}" ]
[ "get", "attribute", "boolean" ]
[ "public", "boolean", "get", "attribute", "boolean", "(", ")", "{", "return", "attribute", "boolean", ";", "}" ]
[ "wildfly", "is", "on", "the", "cp", ";", "if", "openssl", "native", "is", "on", "the", "path", "then", "openssl", "will", "load", ",", "otherwise", "jsse" ]
[ "public", "void", "test", "wildfly", "open", "s", "s", "l", "(", ")", "throws", "throwable", "{", "assume", "that", "(", "has", "wildfly", ")", "is", "true", "(", ")", ";", "assert", "that", "(", "bind", "socket", "factory", "(", "default", ")", ")", "described", "as", "(", "\"", "sockets", "from", "mode", "\"", "+", "default", ")", "is", "in", "(", "open", "s", "s", "l", ",", "default", "jsse", ")", ";", "}" ]
[ "compare", "diffs", "with", "snapshot", "id" ]
[ "public", "int", "compare", "to", "(", "integer", "that", ")", "{", "return", "diff", "compare", "to", "(", "that", ")", ";", "}" ]