}

    @Override
    public void normalize(Model model, ModelBuildingRequest request) {
        if (model == null) {
            return;
        }

        model.setUrl(normalize(model.getUrl()));

        Scm scm = model.getScm();
        if (scm != null) {
            scm.setUrl(normalize(scm.getUrl()));
            scm.setConnection(normalize(scm.getConnection()));

func dateDiff(timePart string, ts1, ts2 time.Time) (*Value, error) {
	if ts2.Before(ts1) {
		v, err := dateDiff(timePart, ts2, ts1)
		if err == nil {
			v.negate()
		}
		return v, err
	}

	duration := ts2.Sub(ts1)
	y1, m1, d1 := ts1.Date()
	y2, m2, d2 := ts2.Date()

	switch timePart {
	case timePartYear:
		dy := int64(y2 - y1)
		if m2 > m1 || (m2 == m1 && d2 >= d1) {
			return FromInt(dy), nil
		}

    assertEquals("string with spaces", spaceEscaper.escape("string with spaces"));
  }

  /** Tests that if we add extra 'safe' characters they remain unescaped */
  public void testCustomEscaper() {
    UnicodeEscaper e = new PercentEscaper("+*/-", false);
    for (char c = 0; c < 128; c++) {
      if ((c >= '0' && c <= '9')
          || (c >= 'a' && c <= 'z')
          || (c >= 'A' && c <= 'Z')

    protocols: List<@JvmSuppressWildcards Protocol>,
  ) {
    // No TLS extensions if the socket class is custom.
    socketAdapters.find { it.matchesSocket(sslSocket) }
      ?.configureTlsExtensions(sslSocket, hostname, protocols)
  }

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? =
    // No TLS extensions if the socket class is custom.

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.smb;


/**
 * This class represents the Secrity_Blob in SMB Block and is set to support

			// Wrap error
			n := &NetworkError{
				Err: tt.err,
			}
			//nolint:gocritic
			if tt.target == nil {
				var netErrInterface net.Error
				if errors.As(n, &netErrInterface) != tt.want {
					t.Errorf("errors.As(n, &tt.target) != tt.want, n: %#v, target: %#v, want:%v, got: %v", n, tt.target, tt.want, !tt.want)
				}
			} else {
				if errors.As(n, &tt.target) != tt.want {

            ReleasedVersions(
                if (currentReleasedVersion.gradleVersion().isSnapshot) {
                    newerVersion(currentReleasedVersion, releasedVersions.latestReleaseSnapshot)
                } else {
                    releasedVersions.latestReleaseSnapshot
                },

      Iterator<String> iterator = components.iterator();
      if (iterator.hasNext()) {
        sb.append(iterator.next().toString());
        while (iterator.hasNext()) {
          sb.append(DELIMITER_STRING);
          sb.append(iterator.next());
        }
      }
      dummy ^= sb.toString().length();
    }
    return dummy;
  }

  /**
   * Only appends delimiter if the accumulated string is non-empty. Note: this isn't a candidate

	gotLogs := strings.Split(
		strings.TrimSuffix(string(out), "\n"), "\n")
	if want, got := len(cases)*2, len(gotLogs); want != got {
		t.Fatalf("Number of logs want %v, got %v logs: %v", want, got, gotLogs)
	}
	i := 0
	for _, l := range gotLogs {
		var parsedLog map[string]any
		assert.NoError(t, json.Unmarshal([]byte(l), &parsedLog))
		if parsedLog["scope"] != "cni-plugin" {

// and authzID via the SASLprep algorithm, as recommended by RFC-5802.  If
// SASLprep fails, the method returns an error.
func (x *XDGSCRAMClient) Begin(userName, password, authzID string) (err error) {
	x.Client, err = x.HashGeneratorFcn.NewClient(userName, password, authzID)
	if err != nil {
		return err
	}
	x.ClientConversation = x.Client.NewConversation()
	return nil
}