} else if (memberType.contains("role")) {
                                addGroupOrRoleName(roleList, value, useDomainServices);
                            } else {
                                addGroupOrRoleName(groupList, value, useDomainServices);
                            }
                        } else if (logger.isDebugEnabled()) {

            // buffer, then append it with a preceding space...again, not sure what else to
            // do other than collapse whitespace.
            // NOTE: The case of a trailing quote is handled by nullifying the arg buffer.
            if (!addedToBuffer) {
                if (currentArg != null) {
                    currentArg.append(' ').append(arg);
                } else {
                    cleaned.add(arg);
                }
            }

     * @return The {@literal byte} array
     */
    public static byte[] toBinary(final Object o) {
        if (o instanceof byte[]) {
            return (byte[]) o;
        } else if (o == null) {
            return null;
        } else {
            assertArgument("o", o instanceof String, o.getClass().toString());
            return ((String) o).getBytes();
        }
    }

            req.setCreateDisposition(Smb2CreateRequest.FILE_OVERWRITE_IF);
        } else if ((flags & SmbConstants.O_TRUNC) == O_TRUNC) {
            req.setCreateDisposition(Smb2CreateRequest.FILE_OVERWRITE);
        } else if ((flags & SmbConstants.O_EXCL) == O_EXCL) {
            req.setCreateDisposition(Smb2CreateRequest.FILE_CREATE);
        } else if ((flags & SmbConstants.O_CREAT) == O_CREAT) {

    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    if (supportsRemove()) {
      table.clear();
      assertEquals(0, table.size());
      assertFalse(table.containsRow("foo"));
    } else {
      assertThrows(UnsupportedOperationException.class, () -> table.clear());
    }
  }

  public void testPut() {
    assertThat(table.put("foo", 1, cellValue('a'))).isNull();

                    return true;
                } else {
                    context.debug("Property " + propertyName + " version " + currentVersion + " is already >= "
                            + upgrade.minVersion);
                }
            } else {
                context.warning("Property " + propertyName + " not found in POM properties");
            }
        } else {

                    effectiveTriggerBranches.add(BOT_DAILY_UPGRADLE_WRAPPER_BRANCH)
                }

                triggers.vcsTrigger(effectiveTriggerBranches, enableTriggers)
            } else if (stage.trigger != Trigger.NEVER) {
                val effectiveTriggerBranches = mutableListOf(model.branch.branchName)

                if (model.branch.isMaster) {

          entriesByLowerBound.lowerEntry(subRange.upperBound);
      if (upperEntry == null) {
        throw new NoSuchElementException();
      } else if (upperEntry.getValue().getUpperBound().compareTo(subRange.upperBound) >= 0) {
        upperBound = subRange.upperBound;
      } else {
        upperBound = upperEntry.getValue().getUpperBound();
      }
      return Range.create(lowerBound, upperBound);
    }

    @Override

                        wantedNature = Metadata.Nature.RELEASE_OR_SNAPSHOT;
                    } else {
                        wantedNature = Metadata.Nature.RELEASE;
                    }
                } else {
                    wantedNature = Metadata.Nature.valueOf(natureString.toUpperCase(Locale.ROOT));
                }

			}
			builder.WriteQuoted(column)
		}
	} else {
		builder.WriteByte('*')
	}
}

func (s Select) MergeClause(clause *Clause) {
	if s.Expression != nil {
		if s.Distinct {
			if expr, ok := s.Expression.(Expr); ok {
				expr.SQL = "DISTINCT " + expr.SQL
				clause.Expression = expr
				return
			}
		}

		clause.Expression = s.Expression
	} else {
		clause.Expression = s
	}
}