I can't imagine a whole lot of use for this one.
199900
def assert_access_without_login(*actions)
			user_options = actions.extract_options!

			options = {}
			if ( self.constants.include?('ASSERT_ACCESS_OPTIONS') )
				options.merge!(self::ASSERT_ACCESS_OPTIONS)
			end
			options.merge!(user_options)
			actions += options[:actions]||[]

			m_key = options[:model].try(:underscore).try(:to_sym)

			test "#{brand}AWoL should get new without login" do
				get :new
				assert_response :success
				assert_template 'new'
				assert assigns(m_key), "#{m_key} was not assigned."
				assert_nil flash[:error], "flash[:error] was not nil"
			end if actions.include?(:new) || options.keys.include?(:new)

			test "#{brand}AWoL should post create without login" do
				args = if options[:create]
					options[:create]
				elsif options[:attributes_for_create]
					{m_key => send(options[:attributes_for_create])}
				else
					{}
				end
				assert_difference("#{options[:model]}.count",1) do
					send(:post,:create,args)
				end
				assert_response :redirect
				assert_nil flash[:error], "flash[:error] was not nil"
			end if actions.include?(:create) || options.keys.include?(:create)

#			test "should NOT get edit without login" do
#				args=[]
#				if options[:factory]
#					obj = Factory(options[:factory])
#					args.push(:id => obj.id)
#				end
#				send(:get,:edit, *args)
#				assert_redirected_to_login
#			end if actions.include?(:edit) || options.keys.include?(:edit)
#
#			test "should NOT put update without login" do
#				args={}
#				if options[:factory]
#					obj = Factory(options[:factory])
#					args[:id] = obj.id
#					args[options[:factory]] = Factory.attributes_for(options[:factory])
#				end
#				send(:put,:update, args)
#				assert_redirected_to_login
#			end if actions.include?(:update) || options.keys.include?(:update)

			test "#{brand}AWoL should get show without login" do
				args={}
				if options[:method_for_create]
					obj = send(options[:method_for_create])
					args[:id] = obj.id
				end
				send(:get,:show, args)
				assert_response :success
				assert_template 'show'
				assert assigns(m_key), "#{m_key} was not assigned."
				assert_nil flash[:error], "flash[:error] was not nil"
			end if actions.include?(:show) || options.keys.include?(:show)

#			test "should NOT delete destroy without login" do
#				args=[]
#				if options[:factory]
#					obj = Factory(options[:factory])
#					args.push(:id => obj.id)
#				end
#				assert_no_difference("#{options[:model]}.count") do
#					send(:delete,:destroy,*args)
#				end
#				assert_redirected_to_login
#			end if actions.include?(:destroy) || options.keys.include?(:destroy)
#
#			test "should NOT get index without login" do
#				get :index
#				assert_redirected_to_login
#			end if actions.include?(:index) || options.keys.include?(:index)

			test "#{brand}should get index without login" do
				get :index
				assert_response :success
				assert_template 'index'
				assert assigns(m_key.try(:to_s).try(:pluralize).try(:to_sym)),
					"#{m_key.try(:to_s).try(:pluralize).try(:to_sym)} was not assigned."
				assert_nil flash[:error], "flash[:error] was not nil"
			end if actions.include?(:index) || options.keys.include?(:index)

			test "#{brand}should get index without login and items" do
				send(options[:before]) if !options[:before].blank?
				3.times{ send(options[:method_for_create]) } if !options[:method_for_create].blank?
				get :index
				assert_response :success
				assert_template 'index'
				assert assigns(m_key.try(:to_s).try(:pluralize).try(:to_sym)),
					"#{m_key.try(:to_s).try(:pluralize).try(:to_sym)} was not assigned."
				assert_nil flash[:error], "flash[:error] was not nil"
			end if actions.include?(:index) || options.keys.include?(:index)

		end
483837
def low_limit(self) -> Optional[Union[int, float]]:
        
        return self._get_field_value(SpecialDevice.PROP_LOW_LIMIT)
459295
def pick_unused_port():
  
  s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  s.bind(('localhost', 0))
  addr, port = s.getsockname()
  s.close()
  return port
996965
def _usage_overall(raw):
    '''
    
    '''
    data = {}
    for line in raw.split("\n")[1:]:
        keyset = [item.strip() for item in re.sub(r"\s+", " ", line).split(":", 1) if item.strip()]
        if len(keyset) == 2:
            key = re.sub(r"[()]", "", keyset[0]).replace(" ", "_").lower()
            if key in ['free_estimated', 'global_reserve']:  # An extra field
                subk = keyset[1].split("(")
                data[key] = subk[0].strip()
                subk = subk[1].replace(")", "").split(": ")
                data["{0}_{1}".format(key, subk[0])] = subk[1]
            else:
                data[key] = keyset[1]

    return data
623436
function min(keySelector, comparer) {
  let itComparer = typeof comparer === 'function' ? comparer : util.defaultComparer;
  let itKeySelector = typeof keySelector === 'function' ? keySelector : (i) => i;

  let minimum = this.firstOrDefault();

  for (let item of this) {
    minimum = itComparer(itKeySelector(item), itKeySelector(minimum)) < 0 ? item : minimum;
  }

  return minimum;
}
615941
def unused(self):
        
        self._params.update(
            href=self._resource.get('search_unused'))
        return self
751498
def used
      return 0 if max.zero?

      timestamp, amount = redis.hmget(key, 'timestamp', 'amount')
      if timestamp && amount
        time_passed = Time.now.to_f - timestamp.to_i / 1000.0
        drift = max * time_passed / period
        last_amount = [amount.to_f, max].min
        [(last_amount - drift).ceil, 0].max
      else
        0
      end
    end
722317
function () {
            var handleArr = this._handlesArr;
            if (!handleArr || !this._resizable) {
                return;
            }

            for (var i = 0, ii = handleArr.length; i < ii; i++) {
                var cursor = handleArr[i];
                if (this._resizable[cursor]) {
                    this._resizable[cursor].$dispose();
                    this._resizable[cursor] = null;
                }
            }
            this._resizable = null;
        }
507878
private void ensureCapacity() {
		if (size < selectionKeys.length) {
			return;
		}
		SelectionKey[] newArray = new SelectionKey[selectionKeys.length * 2];
		System.arraycopy(selectionKeys, 0, newArray, 0, size);
		selectionKeys = newArray;
	}
161787
def basic_fc_small():
  """"""
  hparams = common_hparams.basic_params1()
  hparams.learning_rate = 0.1
  hparams.batch_size = 128
  hparams.hidden_size = 256
  hparams.num_hidden_layers = 2
  hparams.initializer = "uniform_unit_scaling"
  hparams.initializer_gain = 1.0
  hparams.weight_decay = 0.0
  hparams.dropout = 0.0
  return hparams
794139
public void compact() {
        final int idealCapacity = (int) Math.round(size() * (1.0d / loadFactor));
        rehash(QuickMath.nextPowerOfTwo(idealCapacity));
    }
775208
def use(self, obj, parent_form=None):
        

        if not isinstance(obj, self.input_classes):
            raise RuntimeError('{0!s} cannot handle a {1!s}'.format(self.__class__.__name__, obj.__class__.__name__))

        self.parent_form = parent_form

        if self.title is None:
            self.title = 'file: '+obj.filename
        self._do_use(obj)
611368
function compact (arr) {
  var idx = -1
  var end = arr.length
  var out = []

  while (++idx < end) {
    if (arr[idx]) out.push(arr[idx])
  }

  return out
}
311633
private void compact()
  {
    if (words != null && ((lastWordIndex + 1) << 1) < words.length) {
      words = Arrays.copyOf(words, lastWordIndex + 1);
    }
  }
1074010
def minor_extent(self) -> complex:
        """"""
        return min((self.max() - self.null, self.null - self.min()))
535394
def compact(self):
        """"""
        if self.subscribers:
            level = min(self.subscribers.itervalues())
            if level:
                del self.messages[:level]
            return level
        else:
            level = len(self.messages)
            del self.messages[:]
            return level
605249
public void compact() {
        // Bare-bones iterator: no filter, don't bother with package strings
        for (NodeIterator<T> i = this.getNodeIterator(); i.hasNext();) {
            NodeIndex<T> n = i.next();
            if (n.node.exactKids != null)
                n.node.exactKids.trimToSize();
        }
    }