Exports test.push() to the user API Alias of pushResult.
349158
function( result, actual, expected, message, negative ) {
		var currentAssert = this instanceof Assert ? this : QUnit.config.current.assert;
		return currentAssert.pushResult( {
			result: result,
			actual: actual,
			expected: expected,
			message: message,
			negative: negative
		} );
	}
1355078
final void push(UniCompletion<?,?> c) {
        if (c != null) {
            while (result == null && !tryPushStack(c))
                lazySetNext(c, null); // clear on failure
        }
    }
560098
function pushDeviceFilterByUsers() {
    var users = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        users[_i - 0] = arguments[_i];
    }
    if (users.length <= 0) {
        return {
            type: 'null',
            fieldName: 'user',
            isNull: true
        };
    }
    else if (users.length === 1) {
        return {
            type: 'string',
            fieldName: 'user',
            value: domain.uuidOf(users[0])
        };
    }
    else {
        var uuids = users.map(function (user) { return domain.uuidOf(user); });
        return {
            type: 'stringEnum',
            fieldName: 'user',
            values: uuids
        };
    }
}
662273
function() {
      if( StackMob['useRelativePathForAjax'] ){
        // Build "relative path" (also used for OAuth signing)
        return StackMob.apiDomain ? StackMob.apiDomain : (this.getHostname() + (this.getPort() ? ':' + this.getPort() : '')) + '/';
      } else {
        // Use absolute path and operate through CORS
        return StackMob.apiDomain ? StackMob.apiDomain : (StackMob['API_SERVER'] + '/');
      }
    }
1090009
def pushPath_copy(self, d_msg, **kwargs):
        

        # Parse "header" information
        d_meta              = d_msg['meta']
        d_local             = d_meta['local']
        str_localPath       = d_local['path']
        d_remote            = d_meta['remote']
        d_transport         = d_meta['transport']
        d_copy              = d_transport['copy']

        # Pull the actual data into a dictionary holder
        d_curl                      = {
                                        'remoteServer': self.push_core(d_msg),
                                        'copy': {}
                                       }
        d_curl['copy']['status']    = d_curl['remoteServer']['status']
        if not d_curl['copy']['status']:
            d_curl['copy']['msg']   = "Copy on remote server failed!"
        else:
            d_curl['copy']['msg']   = "Copy on remote server success!"

        return d_curl
760563
function (tests) {
            return new Promise(function (resolve) {
                var visual = argv && argv.visual;
                var visualPort = argv && argv.visualPort || '8002';
                var params = ['test', '--web-security=no', '--server-port=' + serverPort];

                if (visual) {
                    params.push('--visual=' + (visual || 10));
                    params.push('--visual-port=' + visualPort);
                }
                var casperChild = spawn(
                    pathToCasper,
                    params.concat(tests)
                );

                casperChild.stdout.on('data', function (data) {
                    logger('CasperJS:', data.toString().slice(0, -1));
                });

                casperChild.on('close', function (code) {
                    resolve(code);
                });
            });
        }
968332
function pushListener(event) {
    var jsonString = event.data && event.data.text() ? event.data.text() : null;

    if (!jsonString) {
      console.log('Leanplum: Push received without payload, skipping display.');
      return;
    }

    // noinspection JSCheckFunctionSignatures
    var options = JSON.parse(jsonString);

    /** @namespace options.title The title of the push notification. **/
    /** @namespace options.tag The id of the push notification **/
    if (!options || !options.title || !options.tag) {
      console.log('Leanplum: No options, title or tag/id received, skipping ' + 'display.');
      return;
    }

    // Extract open action url. We only support open url action for now.
    /** @namespace options.data.openAction The openAction of the push notification. **/
    if (options.data && options.data.openAction && options.data.openAction.hasOwnProperty(ACTION_NAME_KEY) && options.data.openAction[ACTION_NAME_KEY] === OPEN_URL_ACTION && options.data.openAction.hasOwnProperty(ARG_URL)) {
      openActions[options.tag] = options.data.openAction[ARG_URL];
    }

    // Extract title and delete from options.
    var title = options.title;
    Reflect.deleteProperty(options, 'title');
    /** @namespace self.registration **/
    /** @namespace self.registration.showNotification **/
    event.waitUntil(self.registration.showNotification(title, options));
  }
149524
function handlePushError(pushError, pushHandler) {
    return Platform.async(function(callback) {
        callback();
    })().then(function() {
        
        if (pushError.isConflict()) {
            if (pushHandler && pushHandler.onConflict) {
                // NOTE: value of server record will not be available in case of 409.
                return pushHandler.onConflict(pushError);
            }
        } else if (pushHandler && pushHandler.onError) {
            return pushHandler.onError(pushError);
        }

    }).then(undefined, function(error) {
        // Set isHandled to false even if the user has set it to handled if the onConflict / onError failed 
        pushError.isHandled = false;
    });
}
909066
function( arr, results ) {
		var ret = results || [];

		if ( arr != null ) {
			if ( isArraylike( Object(arr) ) ) {
				jQuery.merge( ret,
					typeof arr === "string" ?
					[ arr ] : arr
				);
			} else {
				core_push.call( ret, arr );
			}
		}

		return ret;
	}
611712
def returner(ret):
    '''
    
    '''

    _options = _get_options(ret)

    user = _options.get('user')
    device = _options.get('device')
    token = _options.get('token')
    title = _options.get('title')
    priority = _options.get('priority')
    expire = _options.get('expire')
    retry = _options.get('retry')
    sound = _options.get('sound')

    if not token:
        raise SaltInvocationError('Pushover token is unavailable.')

    if not user:
        raise SaltInvocationError('Pushover user key is unavailable.')

    if priority and priority == 2:
        if not expire and not retry:
            raise SaltInvocationError('Priority 2 requires pushover.expire and pushover.retry options.')

    message = ('id: {0}\r\n'
               'function: {1}\r\n'
               'function args: {2}\r\n'
               'jid: {3}\r\n'
               'return: {4}\r\n').format(
                    ret.get('id'),
                    ret.get('fun'),
                    ret.get('fun_args'),
                    ret.get('jid'),
                    pprint.pformat(ret.get('return')))

    result = _post_message(user=user,
                           device=device,
                           message=message,
                           title=title,
                           priority=priority,
                           expire=expire,
                           retry=retry,
                           sound=sound,
                           token=token)

    log.debug('pushover result %s', result)
    if not result['res']:
        log.info('Error: %s', result['message'])
    return
224114
def push(self, id):
        ""
        conn = session['connections'].get(id, None)
        if conn:
            msgs = simplejson.loads(request.body)
            for msg in msgs:
                try:
                    cmd = msg.pop(0).upper()
                    assert ' ' not in cmd, "Bad message"
                    if cmd in ('USER', ):
                        sufix = " :"+msg.pop()
                    else:
                        sufix = ''
                    assert not [i for i in msg if ' ' in i], "Bad message"

                    print 'PUSH:', (cmd, msg, sufix)

                    if msg:
                        payload = "%s %s%s\r\n" % (cmd, ' '.join(msg), sufix)
                    else:
                        payload = "%s%s\r\n" % (cmd, sufix)
                    yield request.environ['cogen.call'](conn.sock.sendall)(
                            payload.encode('utf-8'))
                    if isinstance(request.environ['cogen.wsgi'].result, Exception):
                        yield simplejson.dumps(('', 'ERROR', str(e)))
                    else:
                        yield simplejson.dumps(('', 'PUSH_OK', ''))
                except Exception, e:
                    yield simplejson.dumps(('', 'ERROR', str(e)))
        else:
            yield simplejson.dumps(('', 'ERROR', 'Invalid connection id.'))
1343102
def _pushdate_urls(cls, pushdate, branch, target_platform):
        """"""
        url_base = cls.URL_BASE + '/namespaces/gecko.v2.mozilla-' + branch + '.pushdate.' + pushdate

        try:
            base = HTTP_SESSION.post(url_base, json={})
            base.raise_for_status()
        except requests.exceptions.RequestException as exc:
            raise FetcherException(exc)

        product = 'mobile' if 'android' in target_platform else 'firefox'
        json = base.json()
        for namespace in sorted(json['namespaces'], key=lambda x: x['name']):
            yield cls.URL_BASE + '/task/' + namespace['namespace'] + '.' + product + '.' + target_platform
412542
private PushApplication loadPushApplicationWhenAuthorized(HttpServletRequest request) {
        // extract the pushApplicationID and its secret from the HTTP Basic header:
        String[] credentials = HttpBasicHelper.extractUsernameAndPasswordFromBasicHeader(request);
        String pushApplicationID = credentials[0];
        String secret = credentials[1];

        final PushApplication pushApplication = pushApplicationService.findByPushApplicationID(pushApplicationID);
        if (pushApplication != null && pushApplication.getMasterSecret().equals(secret)) {
            return pushApplication;
        }

        // unauthorized...
        return null;
    }
500843
public static String pushOrder(boolean isSandbox, Map<String, String> params) {
		if (isSandbox)
			return doPost(UNIFIEDORDER_SANDBOXNEW_URL, params);
		return doPost(UNIFIEDORDER_URL, params);
	}
196626
public void pushUlterior(String key, Object value) {
        assertArgumentNotNull("key", key);
        assertArgumentNotNull("value", value);
        if (pushedUlteriorMap == null) {
            pushedUlteriorMap = new LinkedHashMap<String, Object>(4);
        }
        pushedUlteriorMap.put(key, value);
    }
360134
function( /* result, actual, expected, message */ ) {
		var assert = this,
			currentTest = ( assert instanceof Assert && assert.test ) || QUnit.config.current;

		// Backwards compatibility fix.
		// Allows the direct use of global exported assertions and QUnit.assert.*
		// Although, it's use is not recommended as it can leak assertions
		// to other tests from async tests, because we only get a reference to the current test,
		// not exactly the test where assertion were intended to be called.
		if ( !currentTest ) {
			throw new Error( "assertion outside test context, in " + sourceFromStacktrace( 2 ) );
		}

		if ( currentTest.usedAsync === true && currentTest.semaphore === 0 ) {
			currentTest.pushFailure( "Assertion after the final `assert.async` was resolved",
				sourceFromStacktrace( 2 ) );

			// Allow this assertion to continue running anyway...
		}

		if ( !( assert instanceof Assert ) ) {
			assert = currentTest.assert;
		}
		return assert.test.push.apply( assert.test, arguments );
	}
685796
async function maybeApi ({ apiAddress, apiOpts, ipfsConnectionTest, IpfsApi }) {
  try {
    const ipfs = new IpfsApi(apiAddress, apiOpts)
    await ipfsConnectionTest(ipfs)
    return { ipfs, provider, apiAddress }
  } catch (error) {
    console.log('Failed to connect to ipfs-api', apiAddress)
  }
}