Checks whether the subject is not equivalent to a {@link MessageLite} with no fields set.
162783
public void isNotEqualToDefaultInstance() {
    if (actual() != null && actual().equals(actual().getDefaultInstanceForType())) {
      failWithoutActual(
          simpleFact(
              lenientFormat(
                  "Not true that (%s) %s is not a default proto instance. It has no set values.",
                  actual().getClass().getName(), actualAsString())));
    }
  }
1100595
public static <T> Validation<T> notNull(String msg) {
        return SimpleValidation.from(Objects::nonNull, msg);
    }
1058429
private boolean isNotBlank(String subject, String resource, String operation) {
        return StringUtils.isNotBlank(subject) && StringUtils.isNotBlank(resource) && StringUtils.isNotBlank(operation);
    }
658680
private boolean isEmptyObject()
    {
        boolean retVal = false;

        /**
         * Check for no attributes
         */
        if (this.attrs == null || (this.attrs != null && this.attrs.isEmpty()))
        {
            /**
             * Check for no sub-children
             */
            if (this.jsonObjects.isEmpty())
            {
                /**
                 * Check for no tag text.
                 */
                if (this.tagText == null || (this.tagText != null && this.tagText.trim().equals("")))
                {
                    retVal = true;
                }
            }
        }

        return retVal;
    }
1216456
int checkAndSendMtcToSession(Session session, JsTopicMessageController msgControl, MessageToClient mtc, Object payload) throws SessionException {
		if (session != null) {
			if (session.isOpen()) {
				try {
					if (null != msgControl) {
						checkMessageTopic(userContextFactory.getUserContext(session.getId()), mtc.getId(), payload, msgControl);
					}
					mtc.setType(MessageType.MESSAGE);
					session.getAsyncRemote().sendObject(mtc);
					return 1;
				} catch (NotRecipientException ex) {
					logger.debug("{} is exclude to receive a message in {}", ex.getMessage(), mtc.getId());
				}
			} else {
				throw new SessionException("CLOSED", null, session);
			}
		}
		return 0;
	}
847810
public static LiteProtoSubject<?, MessageLite> assertThat(@NullableDecl MessageLite messageLite) {
    return assertAbout(protos()).that(messageLite);
  }
629861
@Override
	public boolean isSubjectValid(Subject subject) {
		// TODO Auto-generated method stub
		String encodedjwt = getJwtSSOToken(subject);
		JwtSsoTokenUtils tokenUtil = getJwtSsoTokenConsumerUtils();
		if (tokenUtil != null && encodedjwt != null) {
			return tokenUtil.isJwtValid(encodedjwt);
		}
		return false;
	}
333997
void validateAndPrepare(Message message, Address[] addresses) throws MessagingException {
        if (message.getFrom() == null || message.getFrom().length == 0) {
            fail(message, addresses, "No or empty FROM address set!");
        }
        if (addresses.length == 0) {
            fail(message, addresses, "No RECIPIENTS set!");
        }
        Address[] messageAddresses = message.getAllRecipients();
        if (messageAddresses == null) {
            for(Address address : addresses) {
                message.addRecipient(Message.RecipientType.TO, address);
            }
        } else {
            out:
            for(Address address : addresses) {
                for(Address a : messageAddresses) {
                    if (a == null) {
                        continue;
                    }
                    if (a.equals(address)) {
                        continue out;
                    }
                }
                message.addRecipient(Message.RecipientType.TO, address);
            }
        }
    }
884047
protected void assertNotNullOrEmpty(String value, String message) throws IllegalArgumentException {
        if (value == null || value.length() == 0) {
            throw new IllegalArgumentException(message);
        }
    }
707669
@SuppressWarnings("rawtypes")
    public boolean isInputEmpty() {

        final Object fieldValue = getValue();
        final Class<?> fieldType = getType();

        if(fieldValue == null) {
            return true;

        } else if(Collection.class.isAssignableFrom(fieldType) && ((Collection) fieldValue).isEmpty()) {
            return true;

        } else if(fieldType.isArray()) {

            Class<?> componentType = fieldType.getComponentType();
            int length = Utils.getArraySize(fieldValue, componentType);
            if(length > 0) {
                return false;
            }

            return true;

        }

        return super.isInputEmpty();
    }
265168
public static boolean isNotationMarker(MetaMessage message) {
		return
        	(message.getType()==MidiMessageType.MARKER &&
        			message.getData()[0]==MidiMessageType.NOTATION_MARKER);
	}
793657
public static boolean isUnauthenticated(Subject subject) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, CLASS_NAME + "isUnauthenticated", subject);
        }
        boolean result = subjectHelper.isUnauthenticated(subject);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, CLASS_NAME + "isUnauthenticated", result);
        }
        return result;
    }
140080
function booleanNonStrict(validatedObject, errorText) {
  if (!_.isBoolean(validatedObject)) {
    if (
      !_.isString(validatedObject) ||
      (validatedObject.toLowerCase() !== 'false' && validatedObject.toLowerCase() !== 'true')
    ) {
      throw new ValidationError(errorText || 'Validated object is not Boolean');
    }
  }
  return validatedObject;
}
70254
function notDeepEqual(actual, expected, message) {
    if (!isDeepEqual(actual, expected)) {
      this.pass(message);
    }
    else {
      this.fail({
        actual: actual,
        expected: expected,
        message: message,
        operator: "notDeepEqual"
      });
    }
  }
1204081
public boolean isFilterMatch(BaseMessageHeader messageHeader)
    {
        boolean bMatch = super.isFilterMatch(messageHeader);
        if (bMatch)
        {
            if (!(messageHeader instanceof RecordMessageHeader))
                return false;   // Never
            if (m_iDatabaseType != -1)
                if (m_iDatabaseType != ((RecordMessageHeader)messageHeader).getDatabaseType())
                    return false;   // No match
        }
        return bMatch;  // Match
    }
666428
public boolean validationAsBoolean()
   {
      if (this.getMessageadapter() == null || this.getMessageadapter().getMessagelisteners() == null
            || this.getMessageadapter().getMessagelisteners().isEmpty())
         return false;
      MessageListener mlmd = this.getMessageadapter().getMessagelisteners().get(0);
      if (mlmd.getMessagelistenerType() == null || mlmd.getActivationspec() == null
            || mlmd.getActivationspec().getActivationspecClass() == null)
         return false;
      return true;
   }
1142154
public static boolean isMessagingEngine (byte[] b) {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "isMessagingEngine", new Object[]{ b });

    boolean rc = false;

    if (b.length > 0) {
      rc = (b[0] == MESSAGINGENGINE);
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "isMessagingEngine", Boolean.valueOf(rc));
    return rc;
  }