Make this public for testing
516938
public function boot()
  {
    if ($this->booted) return;
    
    $this->container = $container = new Container();
    
    $this->registerServices      ($container);
    $this->registerRoutes        ($container);
    $this->registerEventListeners($container);
    
    $this->booted = true;
  }
1337300
function makeAccessEntry() {
      accesses.set(object, {
        names:    name ? [name] : null,
        observer: makeAccessedObserver()
      });
    }
792921
def _process_publics(self, contents):
        """"""
        matches = self.RE_PUBLIC.finditer(contents)
        result = {}
        start = 0
        for public in matches:
            methods = public.group("methods")
            #We need to keep track of where the public declarations start so that the unit
            #testing framework can insert public statements for those procedures being tested
            #who are not marked as public
            if start == 0:
                start = public.start("methods")
            for item in re.split(r"[\s&\n,]+", methods.strip()):
                if item.lower() in ["interface", "type", "use"]:
                    #We have obviously reached the end of the actual public
                    #declaration in this regex match.
                    break
                self._dict_increment(result, item.lower())
        return (result, start)
497272
def public(self) -> 'PrettyDir':
        """"""
        return PrettyDir(
            self.obj, [pattr for pattr in self.pattrs if not pattr.name.startswith('_')]
        )
286962
function(data) {
			if (globalConfig.debug) {
				// We grab console via getGlobal() so we can stub it out in tests
				var globalConsole = this.getGlobal('console');
				if (globalConsole && globalConsole.info) {
					globalConsole.info(data);
				}
			}
		}
503031
def public(self):
        """"""
        return bool(lib.EnvSlotPublicP(self._env, self._cls, self._name))
525190
function () {
            var result = {
                name: this._name
            };
            if (!this._test) {
                result.test = false;
            }
            if (this._tags.length) {
                result.tags = this._tags.join(" ");
            }
            return result;
        }
395413
function(that) {
		var summ = this._bugsummary;
		var name = that.constructor.$classname || String(that);
		console.error([
			"Bad argument " + summ.shift(),
			"for " + name + ":",
			"Expected " + summ.shift() + ",",
			"got " + summ.shift() + ":",
			summ.shift()
		].join(" "));
	}
275997
def make_definition(this, &blk)
      is_private = private?(this)
      is_protected = protected?(this)
      alias_target(this).send(:define_method, name, &blk)
      make_private(this) if is_private
      make_protected(this) if is_protected
    end
1018400
function() {
    dom.hide(this.$startHelp);
    dom.hide(this.$results);
    dom.hide(this.$measureTasks);
    dom.hide(this.$measuringPrompt);
    dom.show(this.$startPrompt);
  }
1346623
function(url) {
		if (silentMode) {
			return;
		}

		console.log(
			colors.bold('\nTesting ' + link(url)) +
				' ... please wait, this may take a minute.'
		);
		if (program.timer) {
			console.time('Total test time');
		}
	}
106936
def dump(self):
        '''
        
        '''
        return self.publ.public_bytes(
            encoding=c_ser.Encoding.DER,
            format=c_ser.PublicFormat.SubjectPublicKeyInfo)
876694
function (out) {
            var cfg = this._cfg;
            var linkClass = "xLink_" + cfg.sclass;
            if (cfg.disabled) {
                linkClass = "xLink_" + cfg.sclass + "_disabled xLink_disabled";
            }

            out.write([
                '<a',
                    Aria.testMode ? ' id="' + this._domId + '_link"' : '',
                    ' class="', linkClass, '"',
                    ' href="javascript:(function(){})()"',
                    (cfg.tabIndex != null ? ' tabindex=' + this._calculateTabIndex() + '"' : ''),
                    this._getWaiAriaMarkup(),
                    cfg.disabled ? ' disabled ' : '',
                '>',
                    ariaUtilsString.escapeHTML(cfg.label),
                '</a>'
            ].join(''));
            cfg = null;
        }
520175
function(test) {
      // Make a new row if needed
      if (!test._row) {
        var trow = jsl.$('test_row_template');
        if (!trow) return;

        test._row = trow.cloneNode(true);
        test._row.style.display = '';
        test._row.id = '';
        test._row.onclick = function() {JSLitmus._queueTest(test);};
        test._row.title = 'Run ' + test.name + ' test';
        trow.parentNode.appendChild(test._row);
        test._row.cells[0].innerHTML = test.name;
      }

      var cell = test._row.cells[1];
      var cns = [test.loopArg ? 'test_looping' : 'test_nonlooping'];

      if (test.error) {
        cns.push('test_error');
        cell.innerHTML =
        '<div class="error_head">' + test.error + '</div>' +
        '<ul class="error_body"><li>' +
          jsl.join(test.error, ': ', '</li><li>') +
          '</li></ul>';
      } else {
        if (test.running) {
          cns.push('test_running');
          cell.innerHTML = 'running';
        } else if (jsl.indexOf(JSLitmus._queue, test) >= 0) {
          cns.push('test_pending');
          cell.innerHTML = 'pending';
        } else if (test.count) {
          cns.push('test_done');
          var hz = test.getHz(jsl.$('test_normalize').checked);
          cell.innerHTML = hz != Infinity ? hz : '&infin;';
          cell.title = 'Looped ' + test.count + ' times in ' + test.time + ' seconds';
        } else {
          cell.innerHTML = 'ready';
        }
      }
      cell.className = cns.join(' ');
    }
576848
async def main():
    
    # Create Client from endpoint string in Duniter format
    client = Client(ES_CORE_ENDPOINT)

    # Get the current node (direct REST GET request)
    print("\nGET g1-test/block/current/_source:")
    response = await client.get('g1-test/block/current/_source')
    print(response)

    # Get the node number 2 with only selected fields (direct REST GET request)
    print("\nGET g1-test/block/2/_source:")
    response = await client.get('g1-test/block/2/_source', {'_source': 'number,hash,dividend,membersCount'})
    print(response)

    # Close client aiohttp session
    await client.close()

    # Create Client from endpoint string in Duniter format
    client = Client(ES_USER_ENDPOINT)

    # prompt entry
    pubkey = input("\nEnter a public key to get the user profile: ")

    # Get the profil of a public key (direct REST GET request)
    print("\nGET user/profile/{0}/_source:".format(pubkey))
    response = await client.get('user/profile/{0}/_source'.format(pubkey.strip(' \n')))
    print(response)

    # Close client aiohttp session
    await client.close()
242160
public void makePrivate() {
        if (getPublicMarkerFile().exists()) {
            if (getPublicMarkerFile().delete()) {
                publicAccessCache.put(getName(), false);
            } else {
                Storage.LOG.WARN("Failed to delete public marker for bucket %s - it remains public!", getName());
            }
        }
    }
125410
def public(self):
        
        req = self.request(self.mist_client.uri+'/keys/'+self.id+"/public")
        public = req.get().json()
        return public