sh "mvn clean deploy -DdeployAtEnd=true -B"
              }
            }
          }
        }
      }
    }
  }
}

boolean isDeployedBranch() {
  return env.BRANCH_NAME == 'master' || env.BRANCH_NAME == 'maven-4.0.x' || env.BRANCH_NAME == 'maven-3.9.x'
}

/**

      cachedRequest: Headers,
      newRequest: Request,
    ): Boolean =
      cachedResponse.headers.varyFields().none {
        cachedRequest.values(it) != newRequest.headers(it)
      }

    /** Returns true if a Vary header contains an asterisk. Such responses cannot be cached. */
    fun Response.hasVaryAll(): Boolean = "*" in headers.varyFields()

    /**

            throw IOException("Header index too large ${index + 1}")
          }

          dynamicTable[dynamicTableIndex]!!.name
        }

      private fun isStaticHeader(index: Int): Boolean = index >= 0 && index <= STATIC_HEADER_TABLE.size - 1

      /** index == -1 when new. */
      private fun insertIntoDynamicTable(
        index: Int,
        entry: Header,
      ) {
        var index = index

        assertEquals("\"errorKey\":null", buf.toString());
    }

    // Test append method with Boolean value (other object type)
    public void test_append_booleanValue() {
        StringBuilder buf = new StringBuilder();
        Supplier<Object> supplier = () -> Boolean.TRUE;

        monitorTarget.append(buf, "boolKey", supplier);
        assertEquals("\"boolKey\":\"true\"", buf.toString());
    }

open class RecordingEventListener(
  /**
   * An override to ignore the normal order that is enforced.
   * EventListeners added by Interceptors will not see all events.
   */
  private val enforceOrder: Boolean = true,
) : EventListener() {
  val eventSequence: Deque<CallEvent> = ConcurrentLinkedDeque()

  private val forbiddenLocks = mutableListOf<Any>()

    PreOrderIterator(T root) {
      this.stack = new ArrayDeque<>();
      stack.addLast(singletonIterator(checkNotNull(root)));
    }

    @Override
    public boolean hasNext() {
      return !stack.isEmpty();
    }

    @Override
    public T next() {
      Iterator<T> itr = stack.getLast(); // throws NSEE if empty
      T result = checkNotNull(itr.next());

    @Mock
    SmbNamedPipe pipe;
    @Mock
    SmbTreeHandleImpl tree;
    @Mock
    SmbFileHandleImpl fd;
    @Mock
    Configuration config;

    private SmbPipeInputStream newStreamWithInit(boolean smb2) throws CIFSException {
        when(handle.getPipe()).thenReturn(pipe);
        // init(th) behavior inside SmbFileInputStream constructor
        when(tree.isSMB2()).thenReturn(smb2);

  public int getAndSet(int newValue) {
    int result = value;
    value = newValue;
    return result;
  }

  @Override
  public int hashCode() {
    return value;
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    return obj instanceof Count && ((Count) obj).value == value;
  }

  @Override
  public String toString() {
    return Integer.toString(value);
  }

  private final String s;

  public BaseComparable(String s) {
    this.s = s;
  }

  @Override
  public int hashCode() { // delegate to 's'
    return s.hashCode();
  }

  @Override
  public boolean equals(@Nullable Object other) {
    if (other == null) {
      return false;
    } else if (other instanceof BaseComparable) {
      return s.equals(((BaseComparable) other).s);
    } else {
      return false;
    }

    this.backingIterator = checkNotNull(backingIterator);
  }

  @ParametricNullness
  abstract T transform(@ParametricNullness F from);

  @Override
  public final boolean hasNext() {
    return backingIterator.hasNext();
  }

  @Override
  @ParametricNullness
  public final T next() {
    return transform(backingIterator.next());
  }

  @Override